limitedrun-themekit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a51b3b1624ba7e219bd81a6cd9f8b30afc84e06a
+  data.tar.gz: 6a866143943bb7a2c8fad259df260b74d464fc0a
+SHA512:
+  metadata.gz: 0d904f53e355e680c9bc833d8561d1e5c6f056514ba743e95db579ac64d0ed66a059ee6747596b5c85c56f707fab5667a551886fceb0dcd485cf47a46049dc87
+  data.tar.gz: 7772fd381af595a8079aa62d6cd9dc2cc07fee02b80ea43d7534337f60074d360ae898e3fc45744adbfeaa3c88ba74e05f8634fc6e4056eb3089c7aafad9ebba

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Howard Wilson
+
+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,41 @@
+# limitedrun-themekit
+
+[![Build Status](http://img.shields.io/travis/watsonbox/limitedrun-themekit.svg?style=flat)](https://travis-ci.org/watsonbox/limitedrun-themekit)
+
+Toolkit for developing [Limited Run](http://www.limitedrun.com/) themes locally. Because Limited Run themes are made up of [liquid](http://liquidmarkup.org/) templates, they can't easily be worked on offline. This gem renders the templates locally using mock data to speed up development.
+
+Extracted from my [telescope-pinna](https://github.com/watsonbox/telescope-pinna) theme for [Pinna Records](http://www.pinnarecords.com/).
+
+At the moment this is a work in progress but should be fairly extensible. Please open a pull request if you add functionality.
+
+
+## Installation
+
+    $ gem install limitedrun-themekit
+
+
+## Usage
+
+Get hold of a responsive theme from Limited Run (export from the admin interface), and add a `store.json` to its root. See [store.json](https://github.com/watsonbox/limitedrun-themekit/blob/master/spec/assets/skeleton-theme/store.json) for an example as used in the specs.
+
+Alternatively, clone [one of my themes](https://github.com/watsonbox/telescope-pinna) as a test.
+
+    $ limitedrun-themekit
+
+This command fires up Sinatra on http://localhost:4567/ with a preview of the site.
+
+
+## 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
+
+
+# Todo
+
+* Implement pagination
+* Add more specs
+* Static site generation

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end

data/bin/limitedrun-themekit

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'limitedrun-themekit'
+
+Limitedrun::Themekit::Config.theme_path = ARGV[0] if ARGV[0]
+
+Limitedrun::Themekit::Server.run!

data/lib/limitedrun-themekit.rb

@@ -0,0 +1,10 @@
+require "limitedrun-themekit/version"
+require "limitedrun-themekit/config"
+require "limitedrun-themekit/renderer"
+require "limitedrun-themekit/server"
+
+module Limitedrun
+  module Themekit
+    # Your code goes here...
+  end
+end

data/lib/limitedrun-themekit/config.rb

@@ -0,0 +1,23 @@
+module Limitedrun
+  module Themekit
+    class Config
+      class << self
+        attr_writer :theme_path
+
+        def theme_path
+          @theme_path || '.'
+        end
+
+        DIRS = [:configs_dir, :layouts_dir, :templates_dir, :stylesheets_dir, :javascripts_dir, :snippets_dir]
+        attr_accessor *DIRS
+
+        # Define accessors for directories along with defaults e.g. #configs_dir -> 'configs'
+        DIRS.each do |dir|
+          define_method dir do
+            instance_variable_get("@#{dir}") || dir.to_s.gsub('_dir', '')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/limitedrun-themekit/renderer.rb

@@ -0,0 +1,88 @@
+require 'active_support/core_ext/hash/keys'
+require 'liquid'
+require 'liquid/tags/paginate'
+require 'liquid/tags/contact_form'
+require 'liquid/tags/captcha'
+require 'liquid/tags/lr_include'
+require 'liquid/filters'
+require 'hashie'
+require 'json'
+
+module Limitedrun
+  module Themekit
+    class Renderer < Struct.new(:theme_path, :request_path)
+      def render(template, template_assigns = nil)
+        assigns = global_assigns
+
+        if template_assigns
+          template_assigns.each_key do |k|
+            unless template_assigns[k].is_a?(Hashie::Mash)
+              template_assigns[k] = Hashie::Mash.new(instance_eval &template_assigns[k])
+            end
+          end
+
+          assigns.merge!(template_assigns.stringify_keys)
+        end
+
+        layout = parse_template File.join(Limitedrun::Themekit::Config.layouts_dir, 'default.html')
+        template = parse_template File.join(Limitedrun::Themekit::Config.templates_dir, template)
+
+        layout.render(assigns.merge('content' => template.render(assigns)))
+      end
+
+      def render_string(string)
+        Liquid::Template.parse(string).render('config' => theme_config)
+      end
+
+      protected
+
+      # Assignments for all liquid templates
+      def global_assigns
+        { 'config' => theme_config, 'store' => store }
+      end
+
+      # Theme configuration extracted from config/defaults.js and store.config overrides
+      def theme_config
+        return @theme_config if @theme_config
+
+        settings = JSON.parse(
+          File.read(
+            File.join(
+              Limitedrun::Themekit::Config.theme_path,
+              Limitedrun::Themekit::Config.configs_dir,
+              'default.json'
+            )
+          )
+        )['settings']
+
+        config = {}
+
+        settings.each do |k, v|
+          config[k] = v['default'] if v['default']
+        end
+
+        if store && store.config
+          store.config.each { |k, v| config[k] = v }
+        end
+
+        @config = config
+      end
+
+      # Store mock data model loaded from store.json
+      def store
+        @store ||= Hashie::Mash.new(JSON.parse(File.read(File.join(Limitedrun::Themekit::Config.theme_path, 'store.json'))))
+      end
+
+      def parse_template(template)
+        Liquid::Template.parse(
+          File.read(
+            File.join(
+              Limitedrun::Themekit::Config.theme_path,
+              template
+            )
+          )
+        )
+      end
+    end
+  end
+end

data/lib/limitedrun-themekit/server.rb

@@ -0,0 +1,70 @@
+require 'sinatra'
+
+module Limitedrun
+  module Themekit
+    class Server < Sinatra::Application
+      get '/' do
+        render 'index.html'
+      end
+
+      get '/news' do
+        render 'news.html', news: Proc.new { store.news }
+      end
+
+      get '/news/posts/:item' do
+        render 'news-item.html', item: Proc.new { store.news.items.first }
+      end
+
+      get '/store' do
+        # Put all products in all categories
+        render 'category.html', category: Proc.new { store.categories.first.merge('products' => store.products) }
+      end
+
+      get '/categories/:category' do
+        # Put all products in all categories
+        render 'category.html', category: Proc.new { store.categories.find { |c| c.url == request_path }.merge('products' => store.products) }
+      end
+
+      get '/products/:slug' do
+        render 'product.html', product: Proc.new { store.products.find { |p| p.url == request_path } }
+      end
+
+      get '/artists' do
+        render 'roster.html', roster: Proc.new { store.roster }
+      end
+
+      get '/artists/:item' do
+        # Associate all products with all roster items
+        render 'roster-item.html', item: Proc.new {
+          store.roster.items.find { |i| i.url == request_path }.merge('products' => store.products)
+        }
+      end
+
+      get '/contact' do
+        render 'contact.html'
+      end
+
+      get '/stylesheets/:file' do
+        content_type :css
+
+        css = File.read(File.join(Config.theme_path, Config.stylesheets_dir, params[:file]))
+        Renderer.new(Config.theme_path).render_string(css)
+      end
+
+      get '/javascripts/:file' do
+        send_file File.join(Config.theme_path, Config.javascripts_dir, params[:file])
+      end
+
+      private
+
+      def render(template, assigns = nil)
+        # For the include tag
+        Liquid::Template.file_system = Liquid::LocalFileSystem.new(
+          File.join(Limitedrun::Themekit::Config.theme_path, Limitedrun::Themekit::Config.snippets_dir)
+        )
+
+        Renderer.new(Config.theme_path, request.path_info).render(template, assigns)
+      end
+    end
+  end
+end

data/lib/limitedrun-themekit/version.rb

@@ -0,0 +1,5 @@
+module Limitedrun
+  module Themekit
+    VERSION = "0.0.1"
+  end
+end

data/lib/liquid/filters.rb

@@ -0,0 +1,57 @@
+module Liquid
+  module Filters
+    # Extracted from locomotivecms/wagon
+    # Write the url of a theme stylesheet
+    # input: name of the css file
+    def stylesheet_url(input)
+      return '' if input.nil?
+
+      if input =~ /^https?:/
+        input
+      else
+        input = "/stylesheets/#{input}" unless input =~ /^\//
+        input = "#{input}.css" unless input[-4..-1] == '.css'
+        input
+      end
+    end
+
+    # Extracted from locomotivecms/wagon
+    # Write the link to a stylesheet resource
+    # input: url of the css file
+    def stylesheet_tag(input, media = 'screen')
+      return '' if input.nil?
+
+      input = stylesheet_url(input)
+
+      %{<link href="#{input}" media="#{media}" rel="stylesheet" type="text/css" />}
+    end
+
+    def script_tag(input)
+      return '' if input.nil?
+
+      %{<script src="/#{Limitedrun::Themekit::Config.javascripts_dir + "/" + input}" type="text/javascript"></script>}
+    end
+
+    def img_tag(input, klass)
+      %{<img src="#{input}" class="#{klass}" />}
+    end
+
+    def link_to_news_item(input)
+      %{<a href="/news/posts/first">#{input['title']}</a>}
+    end
+
+    def link_to_page(input)
+      %{<a href="#{input['path']}">#{input['title']}</a>}
+    end
+
+    def link_to_category(input)
+      %{<a href="#{input[:url]}">#{input[:name]}</a>}
+    end
+
+    def link_to_roster_item(input)
+      %{<a href="#{input[:url]}">#{input[:name]}</a>}
+    end
+  end
+end
+
+::Liquid::Template.register_filter(Liquid::Filters)

data/lib/liquid/tags/captcha.rb

@@ -0,0 +1,20 @@
+module Liquid
+  module Tags
+    class Captcha < Liquid::Tag
+      def initialize(tag_name, args, tokens)
+         super
+      end
+
+      def render(context)
+        %{
+        <script type="text/javascript">
+        var RecaptchaOptions = {"theme":"clean"};
+        </script><script type="text/javascript" src="http://www.google.com/recaptcha/api/challenge?k=6LdWsM8SAAAAAH-DqFDbCl656cx5203ZoGpZxGLs">
+        </script>
+        }
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('captcha', Liquid::Tags::Captcha)

data/lib/liquid/tags/contact_form.rb

@@ -0,0 +1,16 @@
+module Liquid
+  module Tags
+    class ContactForm < Liquid::Block
+      def initialize(tag_name, markup, tokens)
+         super
+      end
+
+      def render(context)
+        %{<form>#{super}</form>}
+        super
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('contact_form', Liquid::Tags::ContactForm)

data/lib/liquid/tags/lr_include.rb

@@ -0,0 +1,143 @@
+# encoding: UTF-8
+# Extracted with a few mods from https://github.com/jekyll/jekyll/blob/master/lib/jekyll/tags/include.rb
+# Liquid's default include tag does not support special chars or extensions in filenames
+
+module Liquid
+  module Tags
+    class IncludeTagError < StandardError
+      attr_accessor :path
+
+      def initialize(msg, path)
+        super(msg)
+        @path = path
+      end
+    end
+
+    class Include < Liquid::Tag
+
+      SYNTAX_EXAMPLE = "{% include 'file.ext' param='value' param2='value' %}"
+
+      VALID_SYNTAX = /([\w-]+)\s*=\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([\w\.-]+))/
+      VARIABLE_SYNTAX = /(?<variable>[^{]*\{\{\s*(?<name>[\w\-\.]+)\s*(\|.*)?\}\}[^\s}]*)(?<params>.*)/
+
+      def includes_dir
+        File.join(File.realpath(Limitedrun::Themekit::Config.theme_path), Limitedrun::Themekit::Config.snippets_dir)
+      end
+
+      def initialize(tag_name, markup, tokens)
+        super
+        matched = markup.strip.match(VARIABLE_SYNTAX)
+        if matched
+          @file = matched['variable'].strip
+          @params = matched['params'].strip
+        else
+          @file, @params = markup.strip.split(' ', 2);
+        end
+        validate_params if @params
+      end
+
+      def parse_params(context)
+        params = {}
+        markup = @params
+
+        while match = VALID_SYNTAX.match(markup) do
+          markup = markup[match.end(0)..-1]
+
+          value = if match[2]
+            match[2].gsub(/\\"/, '"')
+          elsif match[3]
+            match[3].gsub(/\\'/, "'")
+          elsif match[4]
+            context[match[4]]
+          end
+
+          params[match[1]] = value
+        end
+        params
+      end
+
+      def validate_file_name(file)
+        if file !~ /^'[a-zA-Z0-9_\/\.-]+'$/ || file =~ /\.\// || file =~ /\/\./
+            raise ArgumentError.new <<-eos
+Invalid syntax for include tag. File contains invalid characters or sequences:
+
+  #{file}
+
+Valid syntax:
+
+  #{SYNTAX_EXAMPLE}
+
+eos
+        end
+      end
+
+      def validate_params
+        full_valid_syntax = Regexp.compile('\A\s*(?:' + VALID_SYNTAX.to_s + '(?=\s|\z)\s*)*\z')
+        unless @params =~ full_valid_syntax
+          raise ArgumentError.new <<-eos
+Invalid syntax for include tag:
+
+  #{@params}
+
+Valid syntax:
+
+  #{SYNTAX_EXAMPLE}
+
+eos
+        end
+      end
+
+      # Render the variable if required
+      def render_variable(context)
+        if @file.match(VARIABLE_SYNTAX)
+          partial = Liquid::Template.parse(@file)
+          partial.render!(context)
+        end
+      end
+
+      def render(context)
+        dir = includes_dir
+
+        file = render_variable(context) || @file
+        validate_file_name(file)
+
+        path = File.join(dir, file[1...-1])
+        validate_path(path, dir, true)
+
+        begin
+          partial = Liquid::Template.parse(source(path, context))
+
+          context.stack do
+            context['include'] = parse_params(context) if @params
+            partial.render!(context)
+          end
+        rescue => e
+          raise IncludeTagError.new e.message, File.join(INCLUDES_DIR, @file)
+        end
+      end
+
+      def validate_path(path, dir, safe)
+        if safe && !realpath_prefixed_with?(path, dir)
+          raise IOError.new "The included file '#{path}' should exist and should not be a symlink"
+        elsif !File.exist?(path)
+          raise IOError.new "Included file '#{path_relative_to_source(dir, path)}' not found"
+        end
+      end
+
+      def path_relative_to_source(dir, path)
+        File.join(INCLUDES_DIR, path.sub(Regexp.new("^#{dir}"), ""))
+      end
+
+      def realpath_prefixed_with?(path, dir)
+        File.exist?(path) && File.realpath(path).start_with?(dir)
+      end
+
+      # This method allows to modify the file content by inheriting from the class.
+      def source(file, context)
+        File.read(file)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('include', Liquid::Tags::Include)