radius-template 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+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,201 @@
+# Radius::Template
+
+Simple Ruby on Rails wrapper around radius gem.
+
+Based on the work of [Radius Template](https://github.com/macbury/Radius-template).
+
+## Changelog
+
+
+  * Gemification.
+  * Rails 3 compatible.
+  * Some performance things.
+  * Removed autolink option.
+  * Work with any object that respond to method :each, not only ActiveRecord Objects.
+  * Changed the naming of vars from composed class names. Example: WebContent: before => webcontent; after => web_content.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'radius-template'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install radius-template
+
+## Usage
+
+
+### Simple Example
+
+The first argument is a namespace(tag_prefix) for your template
+
+``` ruby
+parser = Radius::Template.new("template")
+
+parser.define_tag 'hello' do |tag|
+  who = tag['who']
+  "Hello #{who}"
+end
+
+parser.parse("<template:hello who="wrold" />")   # => "Hello world"
+parser.parse("<template:hello who="Jack" />")    # => "Hello Jack"
+```
+
+### Passing Variables
+
+In second argument you can pass variables to your template
+
+
+``` ruby
+parser = Radius::Template.new("template", {
+  hello: "world",
+  number: 2.00
+})
+
+parser.parse("<template:hello />")   # => "world"
+parser.parse("<template:number />")  # => "2.00"
+```
+
+### ActiveRecord Objects, Mongoid or any class kind...
+
+The radius radius_attr_accessible tells what attributes will be accessible in the template.
+
+
+``` ruby
+class Post < ActiveRecord::Base
+  radius_attr_accessible :title, :body
+end
+
+parser = Radius::Template.new("blog", {
+  today_posts: Post.all,
+  top_post: Post.top.first
+})
+```
+
+Passing a local variable named posts with Active Record Post array will create this tag `<blog:today_posts />` and it is an array with your posts. Inside this tag you will get this tag `<blog:post />`. The name of this tag is from singleton name of the model. Each attribute specified in _radius_attr_accessible_ is accessible from it (`<blog:post:title />`, `<blog:post:body />`).
+
+``` ruby
+template = <<-TEMPLATE
+  <ul>
+  <blog:today_posts>
+    <li>
+      <blog:post /><br />
+      <blog:post:body>
+    </li>
+  </blog:today_posts>
+  </ul>
+  <p>
+    <blog:top_post>
+      See the top post - <blog:top_post:title />
+    <blog:top_post />
+  </p>
+TEMPLATE
+
+parser.parse(template) # =>
+#
+# <ul>
+#   <li>
+#     <a href="/posts/1">The title of the post</a><br />
+#     Hello World!
+#   </li>
+# </ul>
+# <p>
+#   See the top post - Hello World
+# </p>
+```
+
+
+### Radius Drops
+
+Drops acts like helpers for your template
+
+Create "drops" directory in app folder and add it to load paths in environment.rb
+
+``` ruby
+config.load_paths += %W( #{RAILS_ROOT}/app/drops )
+```
+
+
+Next create a text_drop.rb in app/drops dir:
+
+
+``` ruby
+class SimpleDrop < Radius::Drop
+  include ActionView::Helpers::TextHelper
+
+  register_tag "truncate" do |tag|
+    length = tag['length'] || 255
+    truncate(tag.expand, :length => length.to_i)
+  end
+
+  register_tag "variable_test" do |tag|
+    "#{@a_test_variable} from drop" #you can access variable that your passed into the template
+  end
+end
+```
+
+You must pass drops in the array as third argument
+
+
+
+``` ruby
+parser = Radius::Template.new("app", {
+  a_test_variable: "Hello World"
+}, [SimpleDrop])
+
+template = <<-TEMPLATE
+  <app:truncate length="10">
+    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+  </app:truncate>
+
+  <app:variable_test />
+TEMPLATE
+
+parser.parse(template) # =>  Lorem ipsum dolor sit amet, co...
+                       #     Hello World from Drop
+
+```
+
+
+
+### Radius Drops + ActiveRecord (or Mongoid or any class kind...)
+
+
+What if you have a photo url in your active record model and you want to create a image tag?
+
+
+``` ruby
+class ProductsDrop < Radius::Drop
+
+  register_tag "product:photo" do |tag|
+    product = tag.locals.product rescue tag.missing!
+    if photo
+      attributes = tag.attributes.clone
+      image_tag(product.photo_url, attributes)
+    else
+      image_tag("/image/missing.png")
+    end
+  end
+
+end
+
+# <product:photo alt="product photo" /> # => <img src="/images/product/1.png" alt="product photo" />
+```
+
+
+
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/radius/template.rb

@@ -0,0 +1,6 @@
+require 'radius'
+require "radius/template/version"
+require "radius/template/expose_to_radius"
+require "radius/template/radius_delegation_open_struct_ext"
+require "radius/template/radius_drop"
+require "radius/template/radius_template"

data/lib/radius/template/expose_to_radius.rb

@@ -0,0 +1,22 @@
+module ExposeToRadius
+  module ClassMethods
+    def radius_attr_accessible(*attributes)
+      unless attributes.kind_of?(Array)
+        attributes = [attributes]
+      end
+
+      define_method("to_radius") do
+        attributes
+      end
+    end
+
+  end
+
+  def self.included(receiver)
+    receiver.extend ClassMethods
+  end
+end
+
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, ExposeToRadius)
+end

data/lib/radius/template/radius_delegation_open_struct_ext.rb

@@ -0,0 +1,24 @@
+module Radius
+  module DelegatingOpenStructExt
+
+    def set(key, value)
+      unless object.nil?
+        @object.set(key, value)
+      end
+      @hash[key.to_sym] = value
+    end
+
+    def get(key)
+      val = @hash[key.to_sym]
+
+      if val.nil? && !object.nil?
+        @object.get(key)
+      else
+        val
+      end
+    end
+
+  end
+end
+
+Radius::DelegatingOpenStruct.send(:include, Radius::DelegatingOpenStructExt)

data/lib/radius/template/radius_drop.rb

@@ -0,0 +1,71 @@
+module Radius
+  module Taggable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.module_eval do
+        protected
+          def params
+            @params ||= request.parameters unless request.nil?
+          end
+
+          def request_uri
+            @request_url ||= request.request_uri unless request.nil?
+          end
+      end
+    end
+
+    def render_tag(name, tag_binding)
+      send "tag:#{name}", tag_binding
+    end
+
+    def return_array(name, tag_binding)
+      send "array:#{name}", tag_binding
+    end
+
+    def return_object(name, tag_binding)
+      send "object:#{name}", tag_binding
+    end
+
+    def tags
+      self.methods.grep(/^tag:/).map { |name| name[4..-1] }.sort
+    end
+
+    def arrays
+      self.methods.grep(/^array:/).map { |name| name[6..-1] }.sort
+    end
+
+    def objects
+      self.methods.grep(/^object:/).map { |name| name[7..-1] }.sort
+    end
+
+    module ClassMethods
+      def register_tag(syntax, &block)
+        define_method("tag:#{syntax}", &block)
+      end
+
+      def register_array(key, &block)
+        key = key.gsub("_","-")
+        define_method("array:#{key}", &block)
+      end
+
+      def register_object(key, &block)
+        key = key.gsub("_","-")
+        define_method("object:#{key}", &block)
+      end
+    end
+  end
+
+  class Drop
+    include Radius::Taggable
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::AssetTagHelper
+
+    attr_accessor :template
+
+    def locals=(locals={})
+      locals.each do |key, value|
+        self.instance_variable_set(:"@#{key}", value)
+      end
+    end
+  end
+end

data/lib/radius/template/radius_template.rb

@@ -0,0 +1,172 @@
+module Radius
+  class Template < Context
+    include ActionView::Helpers::TagHelper
+
+    def initialize(tag_prefix,locals = {}, drops = [])
+      super()
+      @tag_prefix = tag_prefix
+      @drops = {}
+      @locals = {}
+
+      self.locals = locals
+      self.drops = drops
+    end
+
+    def drops=(drops=[])
+      template = self
+
+      drops.each do |raw_drop_class|
+        drop_name = raw_drop_class.name
+        unless @drops.key?(drop_name)
+          @drops[drop_name] = raw_drop_class.new
+          @drops[drop_name].template = template
+          @drops[drop_name].tags.each do |name|
+            define_tag(name) { |tag_binding| @drops[drop_name].render_tag(name, tag_binding) }
+          end
+          @drops[drop_name].arrays.each do |name|
+            define_tag(name) do |tag_binding|
+              array = @drops[drop_name].return_array(name, tag_binding)
+              template.build_attributes_for_array(name, array)
+
+              main_klass = array.first.class.name
+              main_klass = main_klass.tableize.singularize unless main_klass.nil?
+              content = ''
+
+              array.each do |element|
+                tag_binding.locals.set(main_klass, element)
+                content << tag_binding.expand
+              end
+
+              content
+            end
+          end
+
+          @drops[drop_name].objects.each do |name|
+            define_tag(name) do |tag_binding|
+              object = @drops[drop_name].return_object(name, tag_binding)
+              if (object.kind_of?(String) || !object.respond_to?(:to_radius))
+                object
+              else
+                template.build_attributes_for_object(name, object)
+                wrap_inside_link(object, tag_binding)
+              end
+            end
+          end
+        end
+
+        @drops[drop_name].locals = @locals
+      end
+    end
+
+    def locals=(locals={})
+      @locals.merge!(locals)
+      @locals.each do |key, value|
+        if value.respond_to?(:to_radius)
+          build_object_tag(key.to_s, value)
+        elsif value.respond_to?(:each)
+          build_enum_tags(key,value)
+        else
+          define_tag key.to_s, :for => value
+        end
+      end
+
+      @drops.each { |name, drop| drop.locals = @locals }
+    end
+
+    def wrap_inside_link(main_obj, tag)
+      main_klass = main_obj.class.name.tableize.singularize
+      attributes = tag.attributes.clone
+      content = tag.expand
+
+      if content.nil? || content.empty?
+        content = main_obj.send(main_obj.to_radius.first)
+        linked = true
+      end
+
+      content
+      end
+    end
+
+    def build_object_tag(key, main_obj)
+      main_klass = main_obj.class.name.tableize.singularize
+      define_tag(key) do |tag|
+        tag.locals.set(main_klass, main_obj)
+        wrap_inside_link(main_obj, tag)
+      end
+
+      build_attributes_for_object(key, main_obj)
+    end
+
+    def build_attributes_for_object(key, object)
+      return unless object.respond_to?(:to_radius)
+      main_klass = object.class.name.tableize.singularize
+      object.to_radius.each do |attribute|
+        value = object.send(attribute)
+        if value.respond_to?(:to_radius)
+          build_object_tag(attribute.to_s, value)
+        elsif value.respond_to?(:each)
+          build_enum_tags(attribute,value)
+        else
+          define_tag ("#{key}:#{attribute.to_s}") do |tag|
+            obj = tag.locals.get(main_klass).send(attribute) rescue tag.missing!
+          end
+
+        end
+
+
+      end
+    end
+
+    def build_enum_tags(key, array=[])
+      key = key.to_s.tableize
+
+      main_klass = array.first.class.name
+      main_klass = main_klass.tableize.singularize unless main_klass.nil?
+
+      define_tag(key) do |tag|
+        content = ''
+
+        array.each do |element|
+          tag.locals.set(main_klass, element)
+          content << tag.expand
+        end
+
+        content
+      end
+
+      return if array.size == 0 || !array.first.respond_to?(:to_radius)
+
+      build_attributes_for_array(key, array)
+    end
+
+    def build_attributes_for_array(key, array=[])
+      main_klass = array.first.class.name
+      main_klass = main_klass.tableize.singularize unless main_klass.nil?
+
+      define_tag("#{key}:#{main_klass}") do |tag|
+        obj = tag.locals.get(main_klass) rescue tag.missing!
+        wrap_inside_link(obj, tag)
+      end
+
+      build_attributes_for_object(key, array.first)
+    end
+
+    def tag_missing(tag, attr, &block)
+      "<strong>ERROR: </strong> undefined tag: #{tag} attributes: #{attr.inspect}"
+    end
+
+    def locals
+      @locals
+    end
+
+    def parser
+      @parser ||= Radius::Parser.new(self, :tag_prefix => @tag_prefix)
+      @parser
+    end
+
+    def parse(input)
+      parser.parse(input)
+    end
+
+  end
+end

data/lib/radius/template/version.rb

@@ -0,0 +1,3 @@
+module RadiusTemplate
+  VERSION = "0.0.1"
+end

data/radius-template.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'radius/template/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "radius-template"
+  spec.version       = RadiusTemplate::VERSION
+  spec.authors       = ["Fourmach", 'José Galisteo Ruiz']
+  spec.email         = ["ceritium@gmail.com"]
+  spec.description   = %q{Simple Ruby on Rails wrapper around radius gem}
+  spec.summary       = %q{Simple Ruby on Rails wrapper around radius gem}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: radius-template
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Fourmach
+- José Galisteo Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple Ruby on Rails wrapper around radius gem
+email:
+- ceritium@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/radius/template.rb
+- lib/radius/template/expose_to_radius.rb
+- lib/radius/template/radius_delegation_open_struct_ext.rb
+- lib/radius/template/radius_drop.rb
+- lib/radius/template/radius_template.rb
+- lib/radius/template/version.rb
+- radius-template.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4468472905617232333
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4468472905617232333
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple Ruby on Rails wrapper around radius gem
+test_files: []