sal 0.1.0 → 0.2.0

data/README.md

@@ -1,7 +1,125 @@
-# sal.rb
 
-sal.rb is a simple attribute language for Ruby. 
+# Warning
+If you hate writing HTML, this project is not for you. Try [Slim](https://github.com/stonean/slim) or one of the many other template languages. Each has its strengths, weaknesses and place in this world.
+
+## About
+Simple Attribute Language (sal.rb) is logic-less with valid HTML. 
+
+## Why
+With all the other options, why sal.rb?
+
+Having spent many years in `<% %>` land with JSP and ERB templates and seeing the issues that arise with this approach, I wanted to eliminate the ability to freely code in views. My first attempt implementing this idea was [RuHL](https://github.com/stonean/ruhl).
+
+RuHL had issues though. First and least important from a proof a concept angle was the name. RuHL rules! Bleh. 
+
+More to the point: RuHL wasn't compilable and therefore didn't fit easily into the world of Ruby templates. After a short time, the frameworks I had support for (Rails and Sinatra) progressed past RuHL's ability to hack its way into the framework.
+
+Earlier this year I started work on [sal.js](https://github.com/stonean/sal.js) to tackle another view related issue. It just so happens that the idea behind RuHL was the way to make sal.js a reality. While working on sal.js, I refined the approach RuHL took to make it smarter.
+
+As it happens, request were made to bring RuHL up-to-date and make it work with the latest and greatest. Also as it happens, this was turning out to be more work that I wanted to put into RuHL knowing the architecture simply wouldn't work in the long term. 
+
+After weeks of distractions and no real clue how to make a compilable RuHL , the solution presented itself and here we are.
+
+## Syntax
+sal.rb works by parsing your HTML looking for a data-sal attribute and executing the value as a method call against the rendering scope. How sal acts depends on the type of response.
+
+#### String
+The simplest of return values is a string. This tells sal to make this value the contents of the tag.
+
+Lets say there's a method called title:
+    
+    def title
+      'This is different'
+    end
+
+Then you have some markup in your template like so:
+
+    <h1 data-sal="title">This will be replaced</h1>
+
+When you render the template you'll get:
+
+    <h1>This is different</h1>
+
+As you've no doubt noticed, the data-sal attribute is gone and the contents have been replaced with the value of the `title` method call.
+
+
+#### Hash
+The next return value sal knows about is a hash. With the exception of an :html key, sal simply treats each the keys as attributes to be added to the tag. The value of the html key becomes the value of the tag.
+
+Lets say there's a method called login_link:
+    
+    def login_link
+      if logged_in?
+        { :href => '/logout', :html => 'Log out' }
+      else
+        { :href => '/login', :html => 'Log in' }
+      end
+    end
+
+Then you have some markup in your template like so:
+
+    <a data-sal="title">Login link</a>
+
+If logged_in is false you'll get:
+
+    <a href='/login'>Log in</a>
+
+
+#### Array
+If the return value is an array, sal repeats the markup for each item in the array applying the contents accordingly.
+
+
+Lets say there's a method called days_of_week:
+
+    def days_of_week
+      %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}
+    end
+
+Then you have some markup in your template like so:
+
+    <select name="day">
+      <option>Please choose</option>
+      <option data-sal='days_of_week'>Monday</option>
+    </select>
+
+When you render the template you'll get:
+
+    <select name="day">
+      <option>Please choose</option>
+      <option>Monday</option>
+      <option>Tuesday</option>
+      <option>Wednesday</option>
+      <option>Thursday</option>
+      <option>Friday</option>
+      <option>Saturday</option>
+      <option>Sunday</option>
+    </select>
+
+But wait, you want the value to be different...
+
+    def days_of_week
+      [ {:value => 0, :html => 'Monday'},
+        {:value => 1, :html => 'Tuesday'},
+        {:value => 2, :html => 'Wednesday'},
+        {:value => 3, :html => 'Thursday'},
+        {:value => 4, :html => 'Friday'},
+        {:value => 5, :html => 'Saturday'},
+        {:value => 6, :html => 'Sunday'} ]
+    end
+
+Same markup as above, but when you render you'll get:
+
+    <select name="day">
+      <option>Please choose</option>
+      <option value='0'>Monday</option>
+      <option value='1'>Tuesday</option>
+      <option value='2'>Wednesday</option>
+      <option value='3'>Thursday</option>
+      <option value='4'>Friday</option>
+      <option value='5'>Saturday</option>
+      <option value='6'>Sunday</option>
+    </select>
+
+That's the basics for now...more documenation to come.
 
-## What?
 
-I haven't gotten to the docs for this project yet, but fortunately [sal.js](http://github.com/stonean/sal.js) does and sal.rb will act accordingly.

data/lib/sal.rb

@@ -1,26 +1,11 @@
 # encoding: utf-8
 
 require 'temple'
+require 'sal/u'
+require 'sal/wrapper'
 require 'sal/parser'
 require 'sal/filter'
 require 'sal/compiler'
 require 'sal/engine'
 require 'sal/template'
 require 'sal/version'
-
-module Sal
-  class << self
-    def parse_for_attributes(result = nil)
-      return unless result.kind_of?(Hash)
-      " #{result.collect{ |k,v| "#{k}='#{v}'" unless k.to_s == 'html' }.compact.join(' ')}"
-    end
-
-    def parse_for_html(result = nil)
-      if result.kind_of?(String)
-        result
-      elsif result.kind_of?(Hash)
-        result.delete(:html)
-      end
-    end
-  end
-end

data/lib/sal/compiler.rb

@@ -3,33 +3,52 @@ module Sal
   # @api private
   class Compiler < Filter
 
-    def on_sal_tag(ele, attrs, closed, content)
-      [:html, :tag, ele, attrs, closed, compile(content)]
+    def on_sal_tag(tag, attrs, content)
+      [:html, :tag, tag, format_attrs(attrs), false, compile(content)]
+    end
+
+    def on_sal_text(incode, text)
+      if incode
+        [:dynamic, "Sal::U.parse_for_html(_saldict, '#{text}')"]
+      else
+        [:static, text]
+      end
+    end
+
+    def on_sal_nested(tag, attrs, content)
+      [:html, :tag, tag, ada(attrs, '_saldict'), false, compile(content)]
     end
 
     def on_sal_code(code, tag, attrs, content)
       tmp1, tmp2 = tmp_var(:sal), tmp_var(:sal)
 
       [:multi,
-        [:block, "#{tmp1} = #{code}"],
-        [:block, "if #{tmp1}.kind_of?(String)"],
-                      [:html, :tag, tag, attrs, false, [:dynamic, tmp1]],
-        [:block, "elsif #{tmp1}.kind_of?(Array)"],
-        [:block,    "#{tmp1}.each do |#{tmp2}|"],
-                       [:html, :tag, tag, ada(attrs, tmp2), false,
-                            [:dynamic, "Sal.parse_for_html(#{tmp2})"]],
+        [:block,  "if (#{tmp1} = _saldict['#{code}'])"],
+        [:block,    "case (#{tmp1})"],
+        [:block,    "when Array"],
+        [:block,      "#{tmp2} = _saldict"],
+        [:block,      "#{tmp1}.each do |_saldict|"],
+                        compile([:sal, :nested, tag, attrs, content]),
+        [:block,      'end'],
+        [:block,      "_saldict = #{tmp2}"],
+        [:block,    "else"],
+                      [:html, :tag, tag, ada(attrs, tmp1), false,
+                        [:dynamic, "Sal::U.parse_for_html(#{tmp1})"]],
         [:block,    'end'],
-        [:block, "else"],
-                    [:html, :tag, tag, ada(attrs, tmp1), false,
-                        [:dynamic, "Sal.parse_for_html(#{tmp1})"]],
-        [:block, 'end'],
+        [:block,  'end'],
       ]
     end
 
     private
 
+    def format_attrs(attrs)
+      a = []
+      attrs.each{ |k,v| a << [k, [:static, v]] }
+      [:multi, [:html, :staticattrs] + a]
+    end
+
     def ada(attrs, tmpvar)
-      attrs.dup << [:dynamic,  "Sal.parse_for_attributes(#{tmpvar})"]
+      [:dynamic,  "Sal::U.parse_for_attributes(#{tmpvar}, #{attrs.inspect})"]
     end
   end
 end

data/lib/sal/filter.rb

@@ -1,13 +1,5 @@
 module Sal
   class Filter < Temple::Filter
     temple_dispatch :sal
-
-    def on_sal_code(code, tag, attrs, content)
-      [:sal, :code, code, tag, attrs, content]
-    end
-
-    def on_sal_tag(tag, attrs, content)
-      [:sal, :tag, tag, attrs, content]
-    end
   end
 end

data/lib/sal/parser.rb

@@ -41,7 +41,8 @@ module Sal
         str.force_encoding(old_enc) unless str.valid_encoding?
       end
 
-      result = [:multi]
+      result = [:multi,
+                [:block, "_saldict = Sal::Wrapper.new(self)"]]
 
       doc = Nokogiri::XML(str)
 
@@ -52,7 +53,7 @@ module Sal
 
     private
 
-    def parse_nodeset(stacks, nodes)
+    def parse_nodeset(stacks, nodes, incode = false)
       nodes.children.each do |node|
         tag = node.name
 
@@ -61,19 +62,21 @@ module Sal
           content = [:multi]
           attrs, code = parse_attrs(node)
           if code
+            incode = true
             stacks.last << [:sal, :code, code, tag, attrs, content]
           else
-            stacks.last << [:sal, :tag, tag, attrs, false, content]
+            incode = false
+            stacks.last << [:sal, :tag, tag, attrs, content]
           end
           stacks << content
-          parse_nodeset(stacks, node) 
+          parse_nodeset(stacks, node, incode)
           stacks.pop
         when Nokogiri::XML::Node::TEXT_NODE
           str = node.text
           if str.strip.empty?
             stacks.last << [:newline]
           else
-            stacks.last << [:static, str] 
+            stacks.last << [:sal, :text, incode, str]
           end
         when Nokogiri::XML::Node::DTD_NODE
           stacks.last << [:static, node.to_s]
@@ -87,17 +90,17 @@ module Sal
 
     def parse_attrs(node)
       code  = nil
-      attrs = []
+      attrs = {}
 
       node.attribute_nodes.each do |an|
         if an.name == 'data-sal'
           code = an.value
         else
-          attrs << [an.name, [:static, an.value]]
+          attrs[an.name.to_s] = an.value
         end
       end
 
-      return [:multi, [:html, :staticattrs] + attrs], code
+      return attrs, code
     end
   end
 end

data/lib/sal/u.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Sal
+  class U 
+    class << self
+      def parse_for_attributes(result = nil, attrs = {})
+        result = result.value if result.kind_of?(Sal::Wrapper)
+
+        return unless result.kind_of?(Hash)
+
+        result = stringify_keys(result)
+
+        # concat values on class attribute
+        if attrs['class'] && result['class']
+          result['class'] = attrs['class'] + ' ' + result['class']
+        end
+
+        " #{result.collect{ |k,v| "#{k}='#{v}'" unless k.to_s == 'html' }.compact.join(' ')}"
+      end
+
+      def parse_for_html(result, text = '')
+        result = result.value if result.kind_of?(Sal::Wrapper)
+        if result.kind_of?(String)
+          result
+        elsif result.kind_of?(Hash)
+          result.delete(:html)
+        else
+          text unless text.strip.empty?
+        end
+      end
+
+      private
+
+      def stringify_keys(result)
+        new = {}
+        result.each{ |k,v| new[k.to_s] = v }
+        new
+      end
+    end
+  end
+end

data/lib/sal/version.rb

@@ -1,3 +1,3 @@
 module Sal
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/sal/wrapper.rb

@@ -0,0 +1,56 @@
+module Sal
+  # For logic-less mode, objects can be encased in the Wrapper class.
+  class Wrapper
+    attr_reader :value, :parent
+
+    def initialize(value, parent = nil)
+      @value, @parent = value, parent
+    end
+
+    # To find the reference, first check for standard method
+    # access by using respond_to?.
+    #
+    # If not found, check to see if the value is a hash and if the
+    # the name is a key on the hash.
+    #
+    # Not a hash, or not a key on the hash, then check to see if there
+    # is an instance variable with the name.
+    #
+    # If the instance variable doesn't exist and there is a parent object,
+    # go through the same steps on the parent object.  This is useful when
+    # you are iterating over objects.
+    def [](name)
+      return wrap(value.send(name)) if value.respond_to?(name)
+      if value.respond_to?(:has_key?)
+        return wrap(value[name.to_sym]) if value.has_key?(name.to_sym)
+        return wrap(value[name.to_s]) if value.has_key?(name.to_s)
+      end
+      return wrap(value.instance_variable_get("@#{name}")) if value.instance_variable_defined?("@#{name}")
+      parent[name] if parent
+    end
+
+    # Empty objects must appear empty for inverted sections
+    def empty?
+      value.respond_to?(:empty) && value.empty?
+    end
+
+    # Used for output
+    def to_s
+      value.to_s
+    end
+
+    private
+
+    def wrap(response)
+      # Primitives are not wrapped
+      if [String, Numeric, TrueClass, FalseClass, NilClass].any? {|primitive| primitive === response }
+        response
+      # Enumerables are mapped with wrapped values (except Hash-like objects)
+      elsif !response.respond_to?(:has_key?) && response.respond_to?(:map)
+        response.map {|v| wrap(v) }
+      else
+        Wrapper.new(response, self)
+      end
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: sal
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Andrew Stone
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-19 00:00:00 -04:00
+date: 2011-04-26 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,7 +63,9 @@ files:
 - lib/sal/filter.rb
 - lib/sal/parser.rb
 - lib/sal/template.rb
+- lib/sal/u.rb
 - lib/sal/version.rb
+- lib/sal/wrapper.rb
 has_rdoc: true
 homepage: http://github.com/stonean/sal.rb
 licenses: []