liquidize 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c380dada73395e35a3dd46636f6b52dabfe91b10
+  data.tar.gz: de63760111e7b5f07d487aeb392fba096f38a189
+SHA512:
+  metadata.gz: 77078eb95e284b675ede95bf29299bee697d0c063d21f853e7738620699a23495c2f70314f0d6c9738b37b1dfc290823c40376bc4b484c674b3d2bed0821de7e
+  data.tar.gz: a7c0f01e368c60ca8713b1231f87d7614b756239a817acac67a656bf5aa581fe0c06b9493f8f9426bb106cf90a5f6c15eefa70f5a8ad4d6adce49b54e2b30081

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store
+spec/dummy/log
+spec/dummy/db/*.sqlite3

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+liquidize

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+env:
+  - DB=sqlite
+script:
+  - cd spec/dummy/
+  - RAILS_ENV=test bundle exec rake db:migrate
+  - cd ../../
+  - bundle exec rspec spec/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alexander Borovykh
+
+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,85 @@
+# Liquidize
+
+[![Build Status](https://travis-ci.org/ImmaculatePine/liquidize.svg?branch=master)](https://travis-ci.org/ImmaculatePine/liquidize)
+[![Code Climate](https://codeclimate.com/github/ImmaculatePine/liquidize/badges/gpa.svg)](https://codeclimate.com/github/ImmaculatePine/liquidize)
+
+Ruby library that adds [Liquid](http://liquidmarkup.org) template language support to your project.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'liquidize'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Include `Liquidize::Model` mixin to your model and specify liquidized attribute:
+
+    class Page
+      include Liquidize::Model
+      attr_accessor :body
+      liquidize :body
+    end
+
+Now you can set the body and render it with any options:
+
+    page = Page.new
+    page.body = "Hello, {{username}}!"
+    page.render_body(username: 'John') # => "Hello, John!"
+
+Liquid works much faster if once parsed template is cached. Just add `liquid_*` pair attribute and Liquidize will use it to store dump of parsed template.
+
+    class Page
+      # ...
+      attr_accessor :body, :liquid_body
+      # ...
+    end
+
+### With ActiveRecord
+
+Liquidize works the same way with ActiveRecord models. The only difference is that parsed template dump will be automatically saved before rendering if your model responds to `liquid_*` attribute.
+
+    rails g model Email message:text liquid_message:text
+    rake db:migrate
+
+Liquidize it:
+
+    class Email < ActiveRecord::Base
+      include Liquidize::Model
+      liquidize :message
+    end
+
+Use it the same way:
+
+    email = Email.create(message: 'How are you doing, {{who}}?')
+    email.render_message(who: 'friend') # parses template before rendering
+    # => "How are you doing, friend?"
+
+    # Now it won't parse template until message will be changed
+    reloaded_email = Email.find(email.id)
+    reloaded_email.render_message(who: 'sir') # does not parse it. Even after reload.
+    # => "How are you doing, sir?"
+
+    reloaded_email.message = 'Oops, I changed the message!'
+    reloaded_email.render_message # parses template again
+    # => "Oops, I changed the message!"
+
+It makes record invalid if there is syntax error in your liquid template:
+
+    # email.message = "Hey, {{username, I think, there is an error."
+    # email.valid? # => false
+
+    # email.message = "Hey, {{username}}, everything is ok now."
+    # email.valid? # => true
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/liquidize/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/lib/liquidize.rb

@@ -0,0 +1,6 @@
+require 'liquidize/version'
+require 'liquidize/helper'
+require 'liquidize/model'
+
+module Liquidize
+end

data/lib/liquidize/helper.rb

@@ -0,0 +1,14 @@
+module Liquidize
+  module Helper
+    # Converts all keys to strings
+    # @params options [Hash] hash which keys should be stringified
+    # @return [Hash] the same hash with stringified keys
+    def self.recursive_stringify_keys(options)
+      if options.is_a?(Hash)
+        options.stringify_keys!
+        options.each { |k, v| recursive_stringify_keys(v) }
+      end
+      options
+    end
+  end
+end

data/lib/liquidize/model.rb

@@ -0,0 +1,100 @@
+require 'liquid'
+
+module Liquidize
+  module Model
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+
+      # Adds Liquid support to the following attribute
+      # @param attribute [String, Symbol] attribute to be liquidized
+      def liquidize(attribute)
+        define_liquid_template_method(attribute)
+        define_parse_liquid_method(attribute)
+        define_render_method(attribute)
+        override_setter(attribute)
+        if defined?(ActiveRecord) && self.ancestors.include?(ActiveRecord::Base)
+          define_validator(attribute)
+          validate "validate_#{attribute}_liquid_syntax"
+        end
+      end
+
+      private
+
+        def define_parse_liquid_method(attribute)
+          define_method "parse_liquid_#{attribute}!" do
+            begin
+              parsed_value = Liquid::Template.parse(body)
+              instance_variable_set("@liquid_#{attribute}_template", parsed_value)
+              if activerecord? && respond_to?("liquid_#{attribute}")
+                send("liquid_#{attribute}=", Base64.strict_encode64(Marshal.dump(parsed_value)))
+              end
+            rescue Liquid::SyntaxError => error
+              instance_variable_set("@#{attribute}_syntax_error", error.message)
+            end
+          end
+        end
+
+        def define_liquid_template_method(attribute)
+          define_method "liquid_#{attribute}_template" do
+            result = instance_variable_get("@liquid_#{attribute}_template")
+            return result unless result.nil?
+
+            if respond_to?("liquid_#{attribute}") && send("liquid_#{attribute}").present?
+              dump = send("liquid_#{attribute}")
+              decoded_template = Marshal.load(Base64.strict_decode64(dump))
+              instance_variable_set("@liquid_#{attribute}_template", decoded_template)
+            else
+              send("parse_#{attribute}_template!")
+              save if activerecord?
+            end
+
+            instance_variable_get("@liquid_#{attribute}_template")
+          end
+        end
+
+        def define_render_method(attribute)
+          define_method "render_#{attribute}" do |options = {}|
+            send("liquid_#{attribute}_template").render(Liquidize::Helper.recursive_stringify_keys(options))
+          end
+        end
+
+        def define_validator(attribute)
+          define_method("validate_#{attribute}_liquid_syntax") do
+            syntax_error = instance_variable_get("@#{attribute}_syntax_error")
+            errors.add(attribute, syntax_error) if syntax_error.present?
+          end
+        end
+
+        def override_setter(attribute)
+          # Undefine old method to prevent warning
+          undef_method "#{attribute}=".to_sym if method_defined? "#{attribute}="
+
+          # Define new method
+          define_method "#{attribute}=" do |value|
+            # Set *_syntax_error instance variable to nil because:
+            #   * old value could be invalid, but the new one is valid
+            #   * it prevents warning
+            instance_variable_set("@#{attribute}_syntax_error", nil)
+            if activerecord?
+              write_attribute(attribute, value)
+            else
+              instance_variable_set("@#{attribute}", value)
+            end
+            send("parse_liquid_#{attribute}!")
+            value
+          end
+        end
+    end
+
+    private
+
+      def activerecord?
+        defined?(ActiveRecord) && self.class.ancestors.include?(ActiveRecord::Base)
+      end
+
+  end
+end

data/lib/liquidize/version.rb

@@ -0,0 +1,3 @@
+module Liquidize
+  VERSION = '0.0.1'
+end

data/liquidize.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'liquidize/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'liquidize'
+  spec.version       = Liquidize::VERSION
+  spec.authors       = ['Alexander Borovykh']
+  spec.email         = ['immaculate.pine@gmail.com']
+  spec.summary       = 'Ruby library that adds Liquid template language support to your project.'
+  spec.description   = 'Ruby library that adds Liquid template language support to your project.'
+  spec.homepage      = ''
+  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.required_ruby_version = '>= 1.9.3'
+
+  spec.add_dependency 'liquid'
+
+  spec.add_development_dependency 'bundler', "~> 1.6"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'rspec'
+end

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/models/non_active_record_page.rb

@@ -0,0 +1,5 @@
+class NonActiveRecordPage
+  include Liquidize::Model
+  attr_accessor :body
+  liquidize :body
+end

data/spec/dummy/app/models/page.rb

@@ -0,0 +1,4 @@
+class Page < ActiveRecord::Base
+  include Liquidize::Model
+  liquidize :body
+end