tight-engine 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 065ac37dc49f5b5e67ec4271bb92f71eee632e0f
-  data.tar.gz: 72dfcdf5eae3c379407c7c698293515e59822db8
+  metadata.gz: d9af08abd886546c991e706361e0a40872e0e6ca
+  data.tar.gz: b9e8bb833bf96cfbc027ff4f446c41b085930b1c
 SHA512:
-  metadata.gz: 50b1e579488cad7dc14f878f8e2605e8d1837500de6e980aa175f14839693e7027d5df4dd078ef2d86a085e1714ee0f94988976cb39ba56b547dfad6a8b00ea9
-  data.tar.gz: 0bc29fa1374faeb73b5949bc6f504f613fad53d39eac471350c69dfae7c6a78ae94e5429a6a927f3aba1eb4c6bb6255791c3112cd72c175f05f231448a13d3eb
+  metadata.gz: da17884b6953ce5babcb31c05a577f114c56f16ae41dde952840a849c0d6f70ea297d92c33025da579b3a491ded507a523d1d810a827cb66b3db962da1280aab
+  data.tar.gz: 1e6484ce7ec08c592a25c9fb9575f853b8826986ca8868883ad3eab2a94d4a95d639bed33d8f7f024ef47573aa8c60b3ff649261ad85cf2120f790457c49d618

data/.gitignore

@@ -1,2 +1,3 @@
 *.rbc
 *.sassc
+Gemfile.lock

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/lib/tight-engine.rb

@@ -0,0 +1,23 @@
+require 'tight-engine/init'
+require 'tight-engine/locale'
+require 'tight-engine/defer'
+require 'tight-engine/template'
+require 'tight-engine/render'
+require 'tight-engine/url'
+require 'tight-engine/utils'
+
+module Tight
+  module Engine
+    def self.registered(app)
+      app.send(:include, Tight::Engine::Init)
+      app.send(:include, Tight::Engine::Locale)
+      app.send(:include, Tight::Engine::Defer)
+      app.send(:include, Tight::Engine::Template)
+      app.send(:include, Tight::Engine::Render)
+      app.send(:include, Tight::Engine::Url)
+      app.send(:include, Tight::Engine::Utils)
+
+      app.default :deferred_elements, []
+    end
+  end
+end

data/lib/tight-engine/defer.rb

@@ -0,0 +1,30 @@
+module Tight
+  module Engine
+    module Defer
+      def placeholders
+        @placeholders ||= {}
+      end
+
+      def defer_element( name, args, opts )
+        return unless settings.deferred_elements.include?(name)
+        placeholders[name] = [ name, args, opts ]
+        "%{placeholder[:#{name}]}"
+      end
+
+      def process_deferred_elements( text )
+        text.to_str.gsub /(\s*)\%\{placeholder\[\:([^\]]+)\]\}/ do
+          if deferred = placeholders[$2]
+            output = process_element *deferred
+            if engine.pretty?
+              $1+output.gsub(/\r|\n|\r\n/, $1)+$1
+            else
+              output
+            end  
+          else
+           ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tight-engine/init.rb

@@ -0,0 +1,120 @@
+require 'ostruct'
+
+module Tight
+  module Engine
+    module Init
+      def engine
+        @tight_env ||= OpenStruct.new
+      end
+
+      def init_page
+        path = normalize_path swift.path
+        page = find_page_or_module path
+        redirect_if_blank page
+        merge_default_params page
+        init_path_pages page
+        @page = page
+      end
+
+      def init_error( errno )
+        init_path_pages
+        @page = Page.first :path => "/error/#{errno}"
+        @page ||= Page.new :title => "Error #{errno}", :text => "page /error/#{errno} not found"
+      end
+
+      def init_swift
+        return  if @_inited
+        init_folders
+        init_media
+        init_locale
+        init_http
+        @_inited = true
+      end
+
+      private
+
+      def find_page_or_module( path )
+        page = Page.first( :conditions => [ "? LIKE IF(is_module,CONCAT(path,'%'),path)", path ], :order => :path.desc )
+        detect_module_slug page, path
+      end
+
+      def normalize_path( path )
+        path.squeeze! '/'
+        path[1] ? path.chomp('/') : path
+      end
+
+      def redirect_if_blank( page )
+        if page && page.parent_id && page.fragment_id == 'page' && page.text.blank? && !page.is_module
+          first_child = page.children.first( :order => :position )
+          redirect first_child.path  if first_child
+        end
+      end
+
+      def merge_default_params( page )
+        params.reverse_merge! Rack::Utils.parse_query(page.params)  if page && page.params.present?
+      end
+
+      def detect_module_slug( page, path )
+        if page && page.is_module
+          swift.module_root = page.path
+          swift.slug = case path[page.path.length]
+          when '/'
+            path[(page.path.length+1)..-1]
+          when nil
+            ''
+          else
+            page = nil
+          end
+        end
+        page
+      end
+
+      def init_path_pages( page = Page.root )
+        while page
+          swift.path_pages.unshift page
+          swift.path_ids.unshift page.id
+          page = page.parent
+        end
+      end
+
+      def init_http
+        swift.http_method = request.env['REQUEST_METHOD']
+        swift.host = request.env['SERVER_NAME']
+        swift.request = request.env['REQUEST_URI']
+        swift.uri = "/#{params[:request_uri]}"
+        swift.path = swift.uri.partition('?').first
+        swift.path_pages = []
+        swift.path_ids = []
+      end
+
+      def init_folders
+        swift.root = Swift::Application.root
+        swift.public = Swift::Application.public_folder
+        swift.views = Swift::Application.views
+      end
+
+      def init_media
+        media = params.has_key?('print') ? 'print' : 'screen'
+        swift.send("#{media}?=", media)
+        swift.media = media
+        swift.send("pretty?=", Padrino.env == :development)
+      end
+
+      def init_locale
+        swift.locales = Option(:locales) || %w(ru en)
+        swift.locale = params[:locale] ? detect_selected_locale : detect_session_locale
+        session[:locale] = swift.locale
+        I18n.available_locales = swift.locales
+        I18n.locale = swift.locale
+      end
+
+      public
+
+      # deprecated
+      def swift
+        warn '#swift method is deprecated'
+        @tight_env ||= OpenStruct.new
+      end
+    end
+  end
+end

data/lib/tight-engine/locale.rb

@@ -0,0 +1,40 @@
+module Tight
+  module Engine
+    module Locale
+      private
+
+      def detect_selected_locale
+        selected_locale = params[:locale].to_s[0..1]
+        if swift.locales.include?(selected_locale)
+          selected_locale.to_sym
+        else
+          detect_session_locale
+        end
+      end
+
+      def detect_session_locale
+        if session[:locale].present? && swift.locales.include?(session[:locale].to_s)
+          session[:locale].to_sym
+        else
+          detect_preferred_locale
+        end
+      end
+
+      def detect_preferred_locale
+        detected_locale = if preferred_languages = request.env['HTTP_ACCEPT_LANGUAGE']
+          (parse_http_accept_language(preferred_languages) & swift.locales).first
+        end
+        detected_locale ||= swift.locales.first
+        detected_locale.to_sym
+      end
+
+      def parse_http_accept_language( languages )
+        languages.gsub(/\s+/,'').split(/,/)
+                 .sort_by{ |tags| -(tags.partition(/;/).last.split(/=/)[1]||1).to_f }
+                 .map{ |language| language[0..1] }.uniq
+      rescue # !!! FIXME detect valid Exceptions
+        []
+      end
+    end
+  end
+end

data/lib/tight-engine/render.rb

@@ -0,0 +1,193 @@
+module Tight
+  module Engine
+    module Render
+      MAX_PARSE_LEVEL = 4
+
+      REGEX_RECURSIVE_BRACKETS = /
+        (?<re>             #
+          \[               #
+          (?:              #
+            (?>[^\[\]]+)   # 1
+            |              #
+            \g<re>         #
+          )*               #
+          \]               #
+        )                  #
+      /x.freeze
+
+      def strip_code( text )
+        text && text.gsub(REGEX_RECURSIVE_BRACKETS, '').strip
+      end
+
+      def engine_render( text )
+        Markdown.render( parse_content( text.to_s ) ).html_safe
+      end
+
+      def inline_render( text )
+        engine_render( text ).gsub(/^<p>(.*)<\/p>$/, '\1').chomp
+      end
+
+      private
+
+      def parse_content( text )
+        limit_recursion do |flags|
+          draft = text.gsub(REGEX_RECURSIVE_BRACKETS) do |tag|
+            internal_tag(tag) || external_tag(tag, flags)
+          end
+          capture_tag_content draft, flags
+        end
+      end
+
+      INTERNAL_TAGS = {
+        'page'  => 'PageLink',
+        'link'  => 'PageLink',
+        'block' => 'Block',
+        'table' => 'Block',
+        'image' => 'Image',
+        'img'   => 'Image',
+        'file'  => 'File',
+        'asset' => 'File',
+        'element' => :self,
+      }.freeze
+
+      def dispatch_element( tag_name, args, opts )
+        element_name = INTERNAL_TAGS[tag_name]  or return
+        element_name = args.shift  if element_name == :self
+        process_element element_name, args, opts
+      end
+
+      REGEX_INTERNAL_TAG = /
+        \[                                                     # [
+        (#{INTERNAL_TAGS.keys.join('|')})                      # 1, -- tag name
+        (                                                      # 2, -- identity
+          (?:[\:\.\#][\w\-]*)*                                 #
+        )                                                      #
+        \s+                                                    #
+        (.*)                                                   # 3, -- arguments
+        \]                                                     # ]
+      /x.freeze
+
+      def internal_tag( tag )
+        data = tag.match(REGEX_INTERNAL_TAG)  or return
+        tag_name, identity, vars = data[1..-1]
+        args, opts = parse_vars vars
+        opts[:title] = detect_title( tag_name, args )  if opts[:title].blank?
+        detect_identity identity, opts
+        dispatch_element tag_name, args, opts
+      end
+
+      def external_tag( tag, flags )
+        tag_name, _, vars = tag[1..-2].partition ' '
+        code = Code.first( :slug => tag_name )  unless tag_name[0] == '/'
+        if code && code.is_single
+          args, opts = parse_vars vars
+          parse_code( code.html, args )
+        else
+          flags[:needs_capturing] = true  if code
+          tag
+        end
+      end
+
+      REGEX_IDENTITY = /
+        [\:\.\#]    # prefix :.#
+        [\w\-]*     # identity name
+      /x.freeze
+
+      def detect_identity( identity, opts )
+        identity.to_s.scan(REGEX_IDENTITY).each do |attr|
+          prefix, name = attr[0], attr[1..-1]
+          case prefix
+          when '#'
+            opts[:id] ||= name
+          when '.'
+            if opts[:class].blank?
+              opts[:class] = name
+            else
+              opts[:class] << ' ' << name
+            end
+          when ':'
+            opts[:instance] = name
+          end
+        end
+      end
+
+      def detect_title( type, args )
+        newtitle = if type == 'element'
+                     args[2..-1]||[]
+                   else
+                     args[1..-1]||[]
+                   end.join(' ').strip
+        parse_content(newtitle)  if newtitle.present?
+      end
+
+      def capture_tag_content( str, flags )
+        return str  unless flags[:needs_capturing]
+        str.gsub( /\[([^\s]*)\s*(.*?)\](.*?)\[\/(\1)\]/m ) do |s|
+          args, _ = parse_vars $2
+          code = Code.by_slug $1 #!!! FIXME database call
+          parse_code code.html, args, $3
+        end
+      end
+
+      def limit_recursion
+        @parse_level ||= 0
+        @parse_level += 1
+        raise SystemStackError, 'parse level too deep'  if @parse_level > MAX_PARSE_LEVEL
+        result = yield({})
+        @parse_level -= 1
+        result
+      end
+
+      REGEX_VARS = /
+        (                              # 0
+          ([\S^,]+)\:\s*               # 1
+          (?:                          #
+            ["']([^"']+)["'] |         # 2
+            ([^,'"\s]+)                # 3 "'
+          )                            #
+        ),? |                          #
+        (                              # 4
+          ([^'"\s]+) |                 # 5 "'
+          ["']([^"']+)["'],?           # 6
+        )
+      /x.freeze
+
+      def parse_vars( vars )
+        args = []
+        opts = {}
+        vars.scan(REGEX_VARS).each do |v|
+          opts[v[1].to_sym] = ( v[2] || v[3] )  if v[0]
+          args << ( v[5] || v[6] )  if v[4]
+        end
+        [args, opts]    
+      end
+
+      REGEX_EXTERNAL_TAG = /
+        \[                             #
+          (\d+)                        # 1
+          (?:                          #
+            \:                         #
+            (.*?)                      # 2
+          )?                           #
+        \]                             #
+        |                              #
+        \[                             #
+          (content)                    # 3
+        \]                             #
+      /x.freeze
+
+      def parse_code( html, args, content = '' )
+        html.gsub(REGEX_EXTERNAL_TAG) do |s|
+          idx = $1.to_i
+          if idx > 0
+            (args[idx-1] || $2).to_s
+          elsif $3 == 'content'
+            parse_content content
+          else
+            "[#{tag}]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tight-engine/template.rb

@@ -0,0 +1,60 @@
+module Tight
+  module Engine
+    module Template
+      def process_page
+        process_deferred_elements fragment( @page.fragment_id, :layout => :"layouts/#{@page.layout_id}" )
+      end
+
+      def element( name, *args )
+        opts = Hash === args.last ? args.pop : {}
+        defer_element( name, args, opts ) || process_element( name, args, opts )
+      end
+
+      def element_view( name, opts = {} )
+        fragment name, :elements, opts
+      end
+
+      def fragment( template, type = nil, opts = {} )
+        opts, type = type, nil  if type.kind_of? Hash
+        opts[:layout] ||= false
+        type ||= :fragments
+        render :slim, :"#{type}/#{template}", opts
+      rescue Padrino::Rendering::TemplateNotFound, Errno::ENOENT => e
+        name = template.partition('/').first
+        report_error e, "EngineHelpers##{__method__}@#{__LINE__}", "[#{type.to_s.singularize.camelize} '#{name}' error: #{e.to_s.strip}]"
+      end
+
+      private
+
+      def process_element( name, args, opts )
+        core, view = find_element name, opts[:instance]
+        fill_identity name, opts
+        catch :output do
+          @args, @opts = args, opts
+          binding.eval File.read(core), core  if File.exists?(core)
+          render :slim, view.to_sym, :layout => false, :views => Swift::Application.views
+        end
+      rescue Padrino::Rendering::TemplateNotFound => e
+        report_error e, "EngineHelpers##{__method__}@#{__LINE__}", "[Element '#{name}' error: #{e.strip}]"
+      rescue Exception => e
+        report_error e, "EngineHelpers##{__method__}@#{__LINE__} '#{name}'"
+      end
+
+      def find_element( name, instance = nil )
+        view = "elements/#{name}/view"
+        if instance
+          instance_view = "#{view}-#{instance}"
+          view = instance_view  if File.file?( "#{Swift::Application.views}/#{instance_view}.slim" ) 
+        end
+        [ "#{Swift::Application.views}/elements/#{name}/core.rb", view ]
+      end
+
+      def fill_identity( element_name, opts = {} )
+        @identity = { :class => element_name.dup }
+        @identity[:id] = opts[:id]                                 if opts[:id]
+        @identity[:class] << " #{opts[:class]}"                    if opts[:class]
+        @identity[:class] << " #{element_name}-#{opts[:instance]}" if opts[:instance]
+      end
+    end
+  end
+end