lesmok 0.2.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 17819eb07b14118356c7b0bc52573cd7d0e649b4
+  data.tar.gz: 2cd95f97b6a584a5ef855b67562085f7ab3854d6
+SHA512:
+  metadata.gz: 4210bd01b9e0fbad2a799c486f8264509db2d9ecdaf2611bce6521851756046b63fc5fd8daaf461eefefc1a237721b4a7aff16a37e55c3ea836fbf470309fcbc
+  data.tar.gz: 8072cd00bdc59f49b299465e7a8031e9e962d9b15c8702bed003695b9f8bf8955b8e7209f51c2eb56eaad22b07b0d19c131c2a3e854787e7174af04c0c28de9e

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lesmok.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sixty AS
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# Lesmok
+
+Liquid ExtentionS for MOre Komfort
+
+## Liquid markup language
+
+Read about Liquid at:
+
+- http://liquidmarkup.org/
+- https://github.com/Shopify/liquid
+
+# Using Lesmok
+
+## Drop the Base...
+
+Make any class "meltable" quickly:
+
+```ruby
+class FilmFanatic::Movie
+  include ::Lesmok::Acid::Meltable
+end
+```
+
+... and you can start using it in your Liquid templates immediately.
+
+NOTE: All methods are now delegated (ACID - All Content Is Delegated),
+so you don't want to do this if your liquid templates are "untrustworthy"
+or your object has potentially destructive methods.
+
+## Control the Beat...
+
+The `Lesmok::Acid::Drop` liquid-drop class is used by default unless you:
+
+- specify a `to_liquid` method explicitly in your class,
+- override `liquify_drop_klass` to return your preferred sub-class of `Liquid::Drop`,
+- or create an adjacent `*Drop` class with same naming as your model class.
+
+```ruby
+class FilmFanatic::MovieDrop < ::Lesmok::Acid::Drop    # Quick-n-dirty start.
+  alias :movie :source_object                          # For readability.
+  def rave                                             # Start adding presenter methods you need.
+    "OMG! #{movie.title} is so awesome!"
+  end
+end
+```
+
+As you clean up, you may want to have more explicit drop control and migrate away from using Acid Drop:
+
+```ruby
+class FilmFanatic::MovieDrop < ::Liquid::Drop
+  include ::Lesmok::Acid::Droppable        # To keep compatible with Acid::Drop
+  alias :movie :source_object
+end
+```
+
+
+## Keep your cache
+
+Given that your object has a cache key, you can use the `cached_include` tag in your liquid templates:
+
+```ruby
+class FilmFanatic::Movie
+  include ::Lesmok::Acid::Meltable
+  def cache_key
+    "fantastic-movie-#{self.imdb_id}"
+  end
+end
+```
+
+Then from your template:
+
+```liquid
+{% cached_include 'my/movie/reviews/liquid/template' for { cache_on: fantastic_movie } %}
+```
+
+
+# Installation
+
+## Get tha gem...
+
+Add this line to your application's Gemfile:
+
+    gem 'lesmok'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lesmok
+
+
+## Initialization and configuration
+
+
+```ruby
+Lesmok.configure do |conf|
+  conf.logger = Rails.logger
+  conf.available_cache_stores = {
+    default: Rails.cache,
+    redis:   $redis        # Using Redis is entirely optional.
+  }
+  conf.debugging_enabled   =  Rails.env.development?
+  conf.caching_enabled     =  proc { Rails.env.production? }
+  conf.raise_errors_enabled = Rails.env.development?
+end
+Lesmok::Liquid::Tags.register_tags
+```
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+require 'rake/clean'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+CLEAN.add('pkg')
+
+desc 'Run all examples'
+RSpec::Core::RakeTask.new('spec')
+

data/lesmok.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lesmok/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lesmok"
+  spec.version       = Lesmok::VERSION
+  spec.authors       = ["Sixty AS", "Kent Dahl"]
+  spec.email         = ["info@sixty.no", "kent@sixty.no"]
+  spec.summary       = %q{Liquid ExtentionS for MOre Komfort}
+  spec.description   = %q{Collection of utility classes, tags etc for use with the Liquid templating system.}
+  spec.homepage      = "https://github.com/sixtyno/lesmok"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~>0"
+
+  spec.add_dependency 'activesupport' # , '~> 3.2'
+  spec.add_dependency 'liquid' #, '~> 2.5'
+
+  spec.add_development_dependency 'rspec', '~>3.0'
+
+end

data/lib/lesmok.rb

@@ -0,0 +1,20 @@
+require 'lesmok/version'
+require 'lesmok/config'
+require 'lesmok/tags'
+require 'lesmok/acid'
+require 'lesmok/backwards_compatibility'
+
+module Lesmok
+  module ClassMethods
+    def config
+      @configuration ||= Config.new
+    end
+    def configure
+      yield(config)
+    end
+    def logger
+      config.logger
+    end
+  end
+  extend ClassMethods
+end

data/lib/lesmok/acid.rb

@@ -0,0 +1,11 @@
+require 'liquid'
+require 'lesmok/caching/helpers'
+require 'lesmok/acid/meltable'
+require 'lesmok/acid/drop'
+
+
+module Lesmok
+  module Acid
+    # ...
+  end
+end

data/lib/lesmok/acid/drop.rb

@@ -0,0 +1,64 @@
+module Lesmok
+  module Acid
+
+      ##
+      # Base module for creating liquid drops
+      # which defaults to allowing maximum access
+      # class for liquid drops used with Lesmok.
+      #
+      module Droppable
+        include Helpers
+
+        attr_reader :source_object  # Object we delegate to
+        attr_reader :acid_options   # Any customization options.
+        def initialize(source, opts = {})
+          @source_object = source
+          @acid_options = opts
+        end
+
+        ## Liquify...
+        def to_liquid
+          self
+        end
+
+        ## Solidify
+        def to_solid
+          @source_object
+        end
+
+        ## We default to sending anything through to the source object.
+        def before_method(method_name)
+          if allow_delegating_method_to_source?(method_name)
+            return @source_object.send(method_name)
+          else
+            msg = "[#{self.class}] The method `#{method_name}` is not defined on #{@source_object.inspect[0..127]}."
+            Lesmok.logger.warn(msg) if Lesmok.config.debugging?
+            raise NotImplementedError.new(msg) if Lesmok.config.raise_errors?
+          end
+        end
+
+        def allow_delegating_method_to_source?(name)
+          @source_object.respond_to?(name) # TODO: && !name =~ /(\!\=)$/
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          allow_delegating_method_to_source?(method_name) || super
+        end
+
+        ## Ensure before_method fallbacks are used both from liquid and when using drop directly.
+        def method_missing(method_name, *args)
+          (args.present?) ? super(method_name, *args) : before_method(method_name)
+        end
+
+      end
+
+      ##
+      # Base fallback class for creating Liquid drops with Lesmok
+      #
+      class Drop < ::Liquid::Drop
+        include Droppable
+      end
+
+
+  end
+end

data/lib/lesmok/acid/meltable.rb

@@ -0,0 +1,59 @@
+module Lesmok
+  module Acid
+
+      module Helpers
+        ##
+        # Short-hands for use when switching context
+        # between liquid and Ruby code, to ensure
+        # you get the drop OR the solid source, w/o any overhead.
+        #
+        def melt  ; to_liquid ; end # "Melts" the object into a liquid.
+        def cast  ; to_solid  ; end # "Casts" (as in metal forging) back into the original object.
+        def solid ; to_solid  ; end
+      end
+
+      ##
+      # Indicate that a model can be liquified.
+      #
+      module Meltable
+        include Helpers
+
+        ## Liquify...
+        def to_liquid
+          @liquid_drop ||= liquify_dynamically
+        end
+
+        ## Solidify
+        def to_solid
+          self
+        end
+
+        ##
+        # Fallback to trying to find the drop class dynamically
+        # or use generic AcidDrop if it can't be found.
+        #
+        def liquify_dynamically
+          return @liquid_drop if @liquid_drop
+          klass = liquify_drop_klass || AcidDrop
+          @liquid_drop = klass.new(self)
+        end
+
+        ##
+        # We expect Drop classes to be in same namespace as the object class.
+        #
+        def liquify_drop_klass
+          str = self.class.name + 'Drop'
+          klass = str.split('::').inject(Object) do |mod, class_name|
+            mod.const_get(class_name)
+          end
+          klass
+        rescue NameError => err
+          msg = "[#{self.class}] Could not find liquid drop class..."
+          ::Lesmok.logger.warn(msg) if Lesmok.config.debugging?
+          Drop
+        end
+
+      end
+
+  end
+end

data/lib/lesmok/backwards_compatibility.rb

@@ -0,0 +1,13 @@
+module Lesmok
+  ##
+  # Deprecated namespace.
+  #
+  module Liquid
+    module Dropping
+      AcidDrop     = ::Lesmok::Acid::Drop
+      AcidMeltable = ::Lesmok::Acid::Meltable
+    end
+    Tags           = ::Lesmok::Tags
+    CachingHelpers = ::Lesmok::Caching::Helpers
+  end
+end

data/lib/lesmok/caching/helpers.rb

@@ -0,0 +1,29 @@
+require 'active_support'
+module Lesmok
+  module Caching
+    module Helpers
+
+      module ExpiryCalculation
+        def calculate_expiry(cached_on_obj = nil, expire_in_option = nil, jitter_factor = 0.05)
+          expire_in ||= cached_on_obj && cached_on_obj.respond_to?(:cache_expire_in) && cached_on_obj.cache_expire_in
+          expire_in ||= (expire_in_option || 5).to_i * 60  # TODO: Is option authorative or fallback only?
+          expire_in += rand * expire_in * jitter_factor if jitter_factor  # 5 % random additional time to avoid all expiring at once.
+          expire_in
+        end
+        extend self
+      end
+      module GlobalKeyHandling
+        def global_cache_scope
+          "Lesmok:Liquid"
+        end
+        def full_cache_key_for(cached_on_obj, template_name, global_scope = nil)
+          cache_val = cached_on_obj.to_s if cached_on_obj.kind_of?(String)
+          cache_val ||= cached_on_obj.respond_to?(:cache_key) && cached_on_obj.cache_key
+          "#{global_scope || global_cache_scope}:#{I18n.locale}:cached_include:#{template_name}:#{cache_val}"
+        end
+        extend self
+      end
+
+    end
+  end
+end

data/lib/lesmok/config.rb

@@ -0,0 +1,39 @@
+module Lesmok
+  class Config
+    attr_accessor :logger
+    attr_accessor :cache
+    attr_accessor :caching_enabled
+    attr_accessor :available_cache_stores
+    attr_accessor :debugging_enabled
+    attr_accessor :raise_errors_enabled
+
+    alias :raise_errors? :raise_errors_enabled
+    alias :debugging? :debugging_enabled
+
+    def logger
+      @logger ||= (rails? && ::Rails.logger)
+    end
+
+    def cache
+      @cache ||= find_cache_store(:default) || (rails? && ::Rails.cache) || nil
+    end
+
+    def caching?
+      return false if !@caching_enabled
+      @caching_enabled.kind_of?(Proc) ? @caching_enabled.call : true
+    end
+
+    def find_cache_store(name = nil)
+      name  ||= :default
+      avail_stores = (available_cache_stores || {})
+      store   = avail_stores[name.to_sym]
+      store ||= avail_stores[:default]
+      store ||= cache
+    end
+
+    def rails?
+      Object.const_defined? "Rails"
+    end
+
+  end
+end

data/lib/lesmok/liquidations.rb

@@ -0,0 +1,21 @@
+require 'liquid'
+
+# Optional `to_liquid` definitions injected into various classes.
+#
+# Require this file explicitly to use.
+
+class Symbol
+  def to_liquid
+    to_s
+  end
+end
+
+class Struct
+  def to_liquid
+    hash = Hash.new
+    self.members.each do |k|
+      hash[k.to_s] = self[k]
+    end
+    hash
+  end
+end

data/lib/lesmok/railing/action_view_handler.rb

@@ -0,0 +1,75 @@
+##
+#
+# To register for use in Rails:
+#   ActionView::Template.register_template_handler :liquid, ::Lesmok::Railing::ActionViewHandler'
+#
+# Based on example by Roy van der Meij:
+# - http://royvandermeij.com/blog/2011/09/21/create-a-liquid-handler-for-rails-3-dot-1/
+#
+module Lesmok
+  module Railing
+
+    class ActionViewHandler
+      def self.lesmok_options
+        @lesmok_options ||= {}
+      end
+
+      def self.call(template)
+        "#{self}.new(self).render(#{template.source.inspect}, local_assigns)"
+      end
+
+      def initialize(view)
+        @view = view
+      end
+
+      def render(template, local_assigns = {})
+        @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
+
+        assigns = @view.assigns
+
+        if @view.content_for?(:layout)
+          assigns["content_for_layout"] = @view.content_for(:layout)
+        end
+        assigns.merge!(local_assigns.stringify_keys)
+
+        controller = @view.controller
+        filters = if controller.respond_to?(:liquid_filters, true)
+                    controller.send(:liquid_filters)
+                  elsif controller.respond_to?(:master_helper_module)
+                    [controller.master_helper_module]
+                  else
+                    [controller._helpers]
+                  end
+
+        liquid = ::Liquid::Template.parse(template)
+        render_assigns = assigns.with_indifferent_access
+        render_opts = {:filters => filters, :registers => {:action_view => @view, :controller => @view.controller}}
+        if self.class.lesmok_options[:rethrow_errors]
+          text = liquid.render!(render_assigns, render_opts)
+        else
+          text = liquid.render(render_assigns, render_opts)
+        end
+        if ::Lesmok.config.debugging?
+          log_any_liquid_errors(liquid.errors)
+          log_any_liquid_errors(liquid.warnings, 'warning')
+        end
+
+        text.html_safe
+      end
+
+      def log_any_liquid_errors(errors, type_str = 'error')
+        return if errors.blank?
+        log = ::Rails.logger
+        log.warn "[Lesmok] Template #{type_str}s (#{errors.size}) detected!"
+        errors.each do |err|
+          log.debug "  -- Liquid #{type_str}: #{err}"
+        end
+      end
+
+      def compilable?
+        false
+      end
+    end
+
+  end # Liquid
+end # Lesmok

data/lib/lesmok/tags.rb

@@ -0,0 +1,51 @@
+require 'liquid'
+
+require 'lesmok/tags/error_logging'
+require 'lesmok/tags/cached_include'
+require 'lesmok/tags/erb_include'
+
+module Lesmok
+    module Tags
+
+      def self.register_tags
+        ::Liquid::Template.register_tag('erb_include',    ::Lesmok::Tags::ErbInclude)
+        ::Liquid::Template.register_tag('cached_include', ::Lesmok::Tags::CachedInclude)
+        ::Liquid::Template.register_tag('debug_comment',  ::Lesmok::Tags::DebugComment)
+        ::Liquid::Template.register_tag('include',        ::Lesmok::Tags::DebugInclude) if Lesmok.config.debugging?
+        ::Liquid::Template.register_tag('csrf',           ::Lesmok::Tags::Csrf)
+      end
+
+      class DebugComment < ::Liquid::Block
+        include ErrorLogging
+        def render(context)
+          return '' unless Lesmok.config.debugging?
+          with_exception_logging(context) do
+            "<!-- LIQUID DEBUG: #{super} -->"
+          end
+        end
+      end
+
+      class DebugInclude < ::Liquid::Include
+        include ErrorLogging
+        def render(context)
+          with_exception_logging(context) do
+            result = super
+            if context.errors.present?
+              ::Lesmok.logger.debug " -- Liquid errors (#{context.errors.size}) seen in: #{@template_name}"
+            end
+            result
+          end
+        end
+      end
+
+      class Csrf < ::Liquid::Tag
+        def render(context)
+          controller  = context.registers[:controller]
+          name        = controller.send(:request_forgery_protection_token).to_s
+          value       = controller.send(:form_authenticity_token)
+          %(<input type="hidden" name="#{name}" value="#{value}">)
+        end
+      end
+
+  end
+end

data/lib/lesmok/tags/cached_include.rb

@@ -0,0 +1,70 @@
+require 'liquid'
+require 'lesmok/caching/helpers'
+
+
+module Lesmok
+    module Tags
+
+      class CachedInclude < ::Liquid::Include
+        include ErrorLogging
+
+        include ::Lesmok::Caching::Helpers
+        include ExpiryCalculation
+        extend  GlobalKeyHandling
+
+        def render(context)
+          return super unless fragment_caching_enabled?
+          cached_on_obj = context[@attributes['cache_on']]
+          cache_val = cached_on_obj && cached_on_obj.respond_to?(:cache_key) && cached_on_obj.cache_key
+          cache_val ||= context[@attributes['cache_key']]
+
+          template_name = context[@template_name]
+
+          ## Catch cases where cached_include is used incorrectly.
+          if cache_val.blank?
+            if Lesmok.config.debugging?
+              Lesmok.logger.warn "[#{self.class}] No valid cache key given for '#{template_name}' template!"
+              Lesmok.logger.debug " -- No cache key given nor found for object: #{cached_on_obj.inspect.truncate(64)}"
+            end
+            if Lesmok.config.raise_errors?
+              raise ArgumentError.new("No valid cache key! given for '#{template_name}' template!")
+            end
+          end
+
+          return super unless cache_val.present?
+
+          ## Allow sub-scoping w/o manually creating cache key.
+          cache_subscope = context[@attributes['cache_scope']]
+          cache_val += ":SUBSCOPE-#{cache_subscope}" if cache_subscope.present?
+
+          expire_in = calculate_expiry(cached_on_obj, context[@attributes['expire_in']])
+          cache_key = self.class.full_cache_key_for(cache_val, template_name)
+          cache_store = select_cache_store_for(context)
+          Lesmok.logger.debug "[#{self.class}] Lookup #{cache_key} in #{cache_store}..." if Lesmok.config.debugging?
+          result = cache_store.fetch(cache_key, expires_in: expire_in) do
+            Lesmok.logger.debug "[#{self.class}] --- cache miss on #{cache_key} in #{cache_store}!" if Lesmok.config.debugging?
+            super
+          end
+
+          if context.errors.present?
+            ::Lesmok.logger.debug " -- Liquid errors (#{context.errors.size}) seen in: #{@template_name}"
+          end
+
+          result
+        rescue Exception => err
+          log_exception(err, context)
+          ""
+        end
+
+        def select_cache_store_for(context)
+          cache_store_name = context[@attributes['cache_store']]
+          cache_store = Lesmok.config.find_cache_store(cache_store_name)
+        end
+
+        def fragment_caching_enabled?
+          Lesmok.config.caching?
+        end
+      end
+
+    end
+end

data/lib/lesmok/tags/erb_include.rb

@@ -0,0 +1,53 @@
+require 'liquid'
+
+module Lesmok
+    module Tags
+
+      class ErbInclude < ::Liquid::Include
+        include ErrorLogging
+
+        class ErbRenderer
+          attr_reader :context
+          def initialize(liquid_context, template_name)
+            @context = liquid_context
+            @template_name = template_name
+          end
+          def extract_vars
+            # Not needed if we use action_view directly?
+            ctrl.instance_variables.each do |key|
+              val = ctrl.instance_variable_get(key)
+              self.instance_variable_set(key, val)
+            end if ctrl
+          end
+
+          def ctrl
+            context.registers[:controller]
+          end
+
+          def view
+            context.registers[:action_view]
+          end
+
+          def call(args = {})
+            template_name = context[@template_name]
+            default_args = {
+              partial: template_name,
+              template:  template_name,
+              registers: context.registers,
+              locals: context.scopes.last.with_indifferent_access, # TODO: Make this work?
+              liquid_context: context,
+            }
+            render_args = default_args.merge(args)
+            ctrl.send(:render, render_args)
+          end
+        end
+        def render(context)
+          with_exception_logging(context) do
+            erb = ErbRenderer.new(context, @template_name)
+            erb.call
+          end
+        end
+      end
+
+  end
+end

data/lib/lesmok/tags/error_logging.rb

@@ -0,0 +1,27 @@
+module Lesmok
+  module Tags
+
+      module ErrorLogging
+        def log_exception(err, context)
+          template_name = context[@template_name]
+          err.message << " (in template '#{template_name}')" rescue nil
+          err.blame_file! "#{template_name}.liquid" rescue nil
+          Lesmok.logger.error "[#{self.class}] Liquid error in '#{template_name}': #{err.to_s} \n - #{err.backtrace.first(15).join("\n - ")}"
+        rescue => err
+          Lesmok.logger.error "[#{self.class}] META ERROR: Liquid exception reporting failure: #{err.to_s} \n - #{err.backtrace.first(15).join("\n - ")}"
+        ensure
+          raise err if Lesmok.config.debugging?
+          ""
+        end
+
+        def with_exception_logging(context)
+          begin
+            yield
+          rescue => err
+            log_exception(err, context)
+          end
+        end
+      end
+
+  end
+end

data/lib/lesmok/version.rb

@@ -0,0 +1,3 @@
+module Lesmok
+  VERSION = "0.2.0.pre1"
+end

data/spec/lesmok/caching_helpers_spec.rb

@@ -0,0 +1,14 @@
+require 'lesmok'
+describe ::Lesmok::Caching::Helpers do
+
+  describe described_class::ExpiryCalculation do
+    it "should calculate expiry" do
+      exp = described_class.calculate_expiry
+      expect(exp).to be >= 300
+      expect(exp).to be <= 315
+
+      expect(described_class.calculate_expiry(nil, 10, nil)).to be == 600
+    end
+  end
+
+end

data/spec/lesmok/config_spec.rb

@@ -0,0 +1,28 @@
+require 'lesmok'
+describe ::Lesmok::Config do
+
+  it "should lookup cache with fallback" do
+    config = described_class.new
+    dummy_cache = double
+    config.cache = dummy_cache
+
+    expect(config.cache).to be == dummy_cache
+    expect(config.find_cache_store).to            be == dummy_cache
+    expect(config.find_cache_store(nil)).to       be == dummy_cache
+    expect(config.find_cache_store(:default)).to  be == dummy_cache
+    expect(config.find_cache_store(:unknown)).to  be == dummy_cache
+  end
+
+  it "should allow caching to be toggled dynamically" do
+    config = described_class.new
+    cache_level = 1
+    config.caching_enabled = proc { cache_level > 1 }
+    expect(config.caching?).to be false
+    cache_level = 2
+    expect(config.caching?).to be true
+    cache_level = 0
+    expect(config.caching?).to be false
+
+  end
+
+end

data/spec/lesmok/liquidations_spec.rb

@@ -0,0 +1,28 @@
+require 'lesmok/liquidations'
+
+describe 'Lesmok liquidations' do
+
+  describe 'Symbols' do
+    let(:template){ Liquid::Template.parse("GOT:{{ sym }}") }
+    it "should render symbols" do
+      text = template.render( 'sym' => :symbol )
+      expect(text).to include "GOT:symbol"
+    end
+  end
+
+  describe 'Structs' do
+    let(:anon_klass){ Struct.new(:name, :age) }
+    let(:template){ Liquid::Template.parse("{{ user.name }}/{{ user.age }}") }
+    it "should handle structs" do
+      user = anon_klass.new("OlaNordmann", 77)
+      expect(user.age).to eql(77)
+      text = template.render( 'user' => user )
+      expect(text).to include "OlaNordmann"
+      expect(text).to include "77"
+    end
+
+  end
+
+
+
+end

data/spec/lesmok/tags_spec.rb

@@ -0,0 +1,24 @@
+require 'lesmok'
+describe ::Lesmok::Tags do
+
+  before(:all) do
+    described_class.register_tags
+  end
+
+  describe described_class::DebugComment do
+    let(:template){ Liquid::Template.parse("{% debug_comment %} HUH HUH {% enddebug_comment %}") }
+    it "should render contents in debugging mode" do
+      Lesmok.config.debugging_enabled = true
+      text = template.render
+      expect(text).to include "HUH HUH"
+      expect(text).to include "<!--"
+    end
+
+    it "should not render contents by default" do
+      Lesmok.config.debugging_enabled = false
+      text = template.render
+      expect(text).to be == ""
+    end
+  end
+
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: lesmok
+version: !ruby/object:Gem::Version
+  version: 0.2.0.pre1
+platform: ruby
+authors:
+- Sixty AS
+- Kent Dahl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Collection of utility classes, tags etc for use with the Liquid templating
+  system.
+email:
+- info@sixty.no
+- kent@sixty.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lesmok.gemspec
+- lib/lesmok.rb
+- lib/lesmok/acid.rb
+- lib/lesmok/acid/drop.rb
+- lib/lesmok/acid/meltable.rb
+- lib/lesmok/backwards_compatibility.rb
+- lib/lesmok/caching/helpers.rb
+- lib/lesmok/config.rb
+- lib/lesmok/liquidations.rb
+- lib/lesmok/railing/action_view_handler.rb
+- lib/lesmok/tags.rb
+- lib/lesmok/tags/cached_include.rb
+- lib/lesmok/tags/erb_include.rb
+- lib/lesmok/tags/error_logging.rb
+- lib/lesmok/version.rb
+- spec/lesmok/caching_helpers_spec.rb
+- spec/lesmok/config_spec.rb
+- spec/lesmok/liquidations_spec.rb
+- spec/lesmok/tags_spec.rb
+homepage: https://github.com/sixtyno/lesmok
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Liquid ExtentionS for MOre Komfort
+test_files:
+- spec/lesmok/caching_helpers_spec.rb
+- spec/lesmok/config_spec.rb
+- spec/lesmok/liquidations_spec.rb
+- spec/lesmok/tags_spec.rb
+has_rdoc: