erbside 0.1.0 → 0.2.0

data/work/defunct/css/struct.css

@@ -0,0 +1,51 @@
+/* STRUCTURE */
+
+body {margin:0;padding:0;position:relative;}
+ div {margin:0;padding:0;}
+  h1 {margin:5px 0;}
+  li {padding:3px 0;}
+ pre {margin:10px 0;}
+ pre code {padding:10px 10px;}
+ img {border:none;}
+  td {vertical-align:top;}
+
+/* #header .title .download .logo */
+
+#header {position:relative; padding-right:200px;}
+
+.title {width:720px; margin:0 auto; padding:10px 0;}
+.title ul {padding-left: 20px;}
+
+.download {width:200px;height:120px;float:right;margin-top:30px;padding:10px;border:4px solid;-moz-border-radius:20px;border-radius:20px;}
+.logo {float:right;margin-top:10px;padding:10px;}
+
+/* #nav .menu */
+
+#nav { position: fixed; padding: 20px; right: 0; top: 40px; width: 200px;
+  border-top: 4px solid; border-left: 4px solid; border-bottom: 4px solid;
+  -moz-border-radius-topleft: 20px; -webkit-border-top-left-radius: 20px;
+  -moz-border-radius-bottomleft: 20px; -webkit-border-bottom-left-radius: 20px;
+}
+
+.menu { margin: 0 auto; text-align: left; }
+.menu ul { list-style-type: none; margin: 0px; padding: 0px; width: 100%; position: relative; }
+.menu ul li { margin: 15px 10px 15px 0; line-height: 20px; }
+.menu ul li a { border-top: 0 solid; }
+
+/* #main .doc */
+
+#main { padding: 0px; padding-right: 200px; }
+
+.doc { width: 720px; margin: 0 auto; padding: 20px 0 10px 0; min-height: 890px; }
+.doc h2 { border-left: 0px solid; padding-left: 0; }
+.doc h2 img { margin: 0 0 0 0; }
+.doc h3 { border-bottom: 1px dotted; }
+
+/* #footer .copyright */
+
+#footer { padding-right: 200px; border-top: 0px solid; margin-top: 10px; }
+
+.advert { margin: 30px 0 10px 0; text-align: center; }
+
+.copyright { width: 720px; margin: 0 auto; padding: 0 0 30px 0; }
+

data/work/defunct/inline-old/bash.rb

@@ -0,0 +1,36 @@
+module Till
+
+  class Inline
+
+    require 'till/inline/type'
+
+    # = Base Script Matcher
+    #
+    class Bash < Type
+      EXTENSIONS = %w{ .sh }
+      #PATTERNS   = [
+      #  /^(.*?)\#([ \t]*\:till(\+\d*)?\:)(.*?\S.*?)$/,
+      #  /^(.*?)\#([ \t]*\:till(\+\d*)?\:)[ \t]*\n(?m:.*?)\#[ \t]*\:end\:/,
+      #]
+
+      def self.extensions ; EXTENSIONS ; end
+
+      def self.start?(line)
+        if /^(\s*)(.*?)(\s*\#\s*\:till(\+\d*)?\:\s*)/ =~ line
+          new($&, $1, $2, $3, $4, $')
+        end
+      end
+
+      def stop?(line)
+        if /^\s*\#\s*:end:/ =~ line
+          $&
+        elsif /^\s*[^#]/ =~ line
+          true
+        end
+      end
+    end
+
+  end
+
+end
+

data/work/defunct/inline-old/cpp.rb

@@ -0,0 +1,39 @@
+module Till
+
+  class Inline
+
+    require 'till/inline/type'
+
+    #
+    class Cpp < Type
+
+      EXTENSIONS = %w{ .c .cpp }
+
+      def self.extensions ; EXTENSIONS ; end
+
+      def self.start(line)
+        if /^(\s*)(.*?)(\s*\/(\/|\*)\s*\:till(\+\d*)?\:\s*)/ =~ line
+          new($&, $1, $2, $3, $4, $')
+        end
+      end
+
+      def stop?(line)
+        if marker =~ /\/\*/
+          if /^.*?\*\// =~ line
+            $&
+          end
+        else
+          if /^\s*\#\s*:end:/ =~ line
+            $&
+          elsif /^\s*(?!:\/\/)/ =~ line
+            true
+          end
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/work/defunct/inline-old/css.rb

@@ -0,0 +1,32 @@
+module Till
+
+  class Inline
+
+    require 'till/inline/type'
+
+    # = CSS Matcher
+    #
+    class CSS < Type
+
+      EXTENSIONS = %w{ .css }
+
+      def self.extensions ; EXTENSIONS ; end
+
+      def self.start(line)
+        if /^(\s*)(.*?)(\s*\/\*\s*\:till(\+\d*)?\:\s*)/ =~ line
+          new($&, $1, $2, $3, $4, $')
+        end
+      end
+
+      def stop?(line)
+        if /^(.*?)\*\/(.*?)$/ =~ line
+          $&
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/work/defunct/inline-old/html.rb

@@ -0,0 +1,32 @@
+module Till
+
+  class Inline
+
+    require 'till/inline/type'
+
+    # = HTML Matcher
+    #
+    class Html < Type
+
+      EXTENSIONS = %w{ .html }
+
+      def self.extensions ; EXTENSIONS ; end
+
+      def self.start(line)
+        if /^(\s*)(.*?)(\s*(<!--)\s*\:till(\+\d*)?\:\s*)/ =~ line
+          new($&, $1, $2, $3, $4, $')
+        end
+      end
+
+      def stop?(line)
+        if /-->/ =~ line
+          $&
+        end
+      end
+
+    end#class Html
+
+  end#class Inline
+
+end#module Till
+

data/work/defunct/inline-old/js.rb

@@ -0,0 +1,85 @@
+module Till
+module Inline
+
+    require 'till/inline/type'
+
+    #
+    class Javascript < Parser
+
+      EXTENSIONS = %w{ .js }
+
+      LINE_BACK  = /^(\s*)(.*?)(\s*\/\/\s*\:till)(\+\d*)?(\:)(.*?\S.*?)$/
+
+      LINE_BLOCK = /^(\ *)(.*?)(\ *\/\/\ *\:till(\+\d*)?(\:)(\s*\n))((?m:\/\/.*?\n)*)(\/\/[ \t]*:end:)/
+
+      BLOCK      = /^(.*?)\/\*(\s*\:till(\+\d*)?\:)(?m:.*?)\*\//
+
+      def extensions
+        EXTENSIONS
+      end
+
+      def parse(text)
+        text = parse_line_backs(text)
+        text = parse_line_blocks(text)
+        text = parse_blocks(text)
+      end
+
+      def parse_lines_backs(text)
+        text.gsub(LINE_BACK) do |m|
+          indent = $1
+          front  = $2
+          remark = $3 + $4.to_s + $5 + $6
+          render = $6.strip
+          count  = $4
+          #offset = 1
+          result = render_template(render)
+          format(indent, front, remark, result, count)
+        end
+      end
+
+      def parse_line_blocks(text)
+        text.gsub(LINE_BLOCK) do |m|
+          indent = $1
+          front  = $2
+          remark = $3 + $4.to_s + $5 +$6
+          render = $7.strip.gsub(/^\s*\/\//, '')
+          count  = $3
+          result = render_template(render)
+          format(indent, front, remark, result, count)
+        end
+      end
+
+      def parse_blocks(text)
+        text.gsub(BLOCK) do |m|
+          indent = $1
+          front  = nil
+          remark = $2 + $3.to_s + $4 + $5
+          render = $5.strip
+          count  = $3
+          result = render_template(render)
+          format(indent, front, remark, result, count)
+        end
+      end
+
+      #
+      def format(indent, front, remark, render, multi=nil)
+        size = render.count("\n")
+        if multi || size > 0
+          indent + remark.sub(/:till(\+\d+)?:/, ":till+#{size}:") + "\n" + render
+        else
+          if render =~ /^\s*\^/
+            b = render.index('^') + 1
+            e = render.index(/[<{]/) || - 1
+            m = render[b...e]
+            i = front.index(m)
+            render = front[0...i] + render.sub('^','')
+          end
+          "\n" + indent + render + remark.sub(/:till(\+\d+)?:/, ":till:") + "\n"
+        end
+      end
+
+    end#class Javascript
+
+end#module Inline
+end#module Till
+

data/work/defunct/inline-old/ruby.rb

@@ -0,0 +1,147 @@
+module Till
+
+  class Inline
+
+    require 'till/inline/type'
+
+    # = Ruby Script Matcher
+    #
+    # TODO: Add =begin ... =end matching
+
+    class Ruby < Type
+
+      EXTENSIONS = %w{ .rb }
+
+      #PATTERNS   = [
+      #  /^(.*?)\#([ \t]*\:till(\+\d*)?\:)(.*?\S.*?)$/,
+      #  /^(.*?)\#([ \t]*\:till(\+\d*)?\:)[ \t]*\n(?m:.*?)\#[ \t]*\:end\:/,
+      #  /^=begin\s*\:till\:(.*?)^=end/m 
+      #]
+
+      def self.extensions ; EXTENSIONS ; end
+
+      def self.start?(line)
+        /\#\s*\:till(\+\d*)?\:/ =~ line
+      end
+
+      def self.parse(lines, index)
+        line = lines[index]
+
+        case line
+        when /^(\s*)(.*?)(\s*\#\s*\:till)(\+\d*)?(\:)(.*?\S.*?)$/
+          indent = $1
+          front  = $2
+          remark = $3 + $4.to_s + $5 + $6
+          render = $6.strip
+          count  = $4
+          offset = 1
+
+          [indent, front, remark, render, count, offset]
+
+        when /^(\s*)(\#\s*\:till)(\+\d*)?(\:)(\s*)$/
+          indent = $1
+          front  = nil
+          remark = $2 + $3.to_s + $4 + $5
+          render = $5.strip
+          count  = $3
+
+          i, s = index + 1, nil
+          until s or i == lines.size
+            remain = lines[i]
+            s = stop?(remain)
+            i += 1
+          end
+
+          remark = remark + lines[index+1...i].join("\n")
+          render = render + lines[index+1...i].join("\n")
+
+          [indent, front, remark, render, count, i]
+        end
+      end
+
+      #
+      def self.stop?(line)
+        if md = /^(\s*)(\#\s*:end:)/.match(line)
+          [md, true]
+        elsif md = /^(\s*)[^#]/.match(line)
+          [md, false]
+        end
+      end
+
+      #
+      def self.format(indent, front, remark, render, multi=nil)
+        size = render.count("\n")
+        if multi || size > 0
+          indent + remark.sub(/:till(\+\d+)?:/, ":till+#{size}:") + "\n" + render
+        else
+          if render =~ /^\s*\^/
+            b = render.index('^') + 1
+            e = render.index(/[<{]/) || - 1
+            m = render[b...e]
+            i = front.index(m)
+            render = front[0...i] + render.sub('^','')
+          end
+          "\n" + indent + render + remark.sub(/:till(\+\d+)?:/, ":till:") + "\n"
+        end
+      end
+
+    end#class Ruby
+
+  end#class Inline
+
+end#module Till
+
+
+
+=begin
+    #
+    class Javascript < Type
+      EXTENSIONS = %w{ .js }
+      PATTERNS   = [
+        /^(.*?)\/\/([ \t]*\:till(\+\d*)?\:)(.*?\S.*?)$/,
+        /^(.*?)\/\/([ \t]*\:till(\+\d*)?\:)[ \t]*\n(?m:.*?)\/\/[ \t]*\:end\:/,
+        /^(.*?)\/\*(\s*\:till(\+\d*)?\:)(?m:.*?)\*\//
+      ]
+
+      def self.extensions ; EXTENSIONS ; end
+      def self.patterns   ; PATTERNS   ; end
+    end
+
+
+    #
+    class Cpp < Type
+      EXTENSIONS = %w{ .c .cpp }
+      PATTERNS   = [
+        /^(.*?)\/\/([ \t]*\:till(\+\d*)?\:)(.*?\S.*?)$/,
+        /^(.*?)\/\/([ \t]*\:till(\+\d*)?\:)[ \t]*\n(?m:.*?)\/\/[ \t]*\:end\:/,
+        /^(.*?)\/\*(\s*\:till(\+\d*)?\:)(?m:.*?)\*\//
+      ]
+
+      def self.extensions ; EXTENSIONS ; end
+      def self.patterns   ; PATTERNS   ; end
+    end
+
+
+    #
+    class SGML < Type
+      EXTENSIONS = %w{ .html }
+      PATTERNS   = [
+        /^(.*?)<!--(\s*\:till(\+\d*)?\:)(?m:.*?)-->/
+      ]
+
+      def self.extensions ; EXTENSIONS ; end
+      def self.patterns   ; PATTERNS   ; end
+    end
+
+    #
+    class CSS < Type
+      EXTENSIONS = %w{ .css }
+      PATTERNS   = [
+        /^(.*?)\/\*(\s*\:till(\+\d*)?\:)(?m:.*?)\*\//
+      ]
+
+      def self.extensions ; EXTENSIONS ; end
+      def self.patterns   ; PATTERNS   ; end
+    end
+=end
+

data/work/defunct/inline-old/type.rb

@@ -0,0 +1,91 @@
+module Till
+
+  class Inline
+
+    # = Type Base Class
+    #
+    class Type
+
+      # C L A S S - M E T H O D S
+
+      #
+      def self.map
+        @map ||= (
+          Type.register.inject({}) do |hash, base|
+            base.extensions.each do |ext|
+              hash[ext] = base
+            end
+            hash
+          end
+        )
+      end
+
+      def self.register
+        @register ||= []
+      end
+
+      def self.inherited(base)
+        register << base
+      end
+
+      def self.extensions ; raise ; end
+
+
+      ## A T T R I B U T E S
+
+      #attr :string
+      #attr :indent
+      #attr :front
+      #attr :mark
+      #attr :pad
+      #attr :till
+      #attr :count
+      #attr :body
+      #attr :post
+
+      # Initialize a new type match.
+      #def initialize(opts)
+      #  @line   = opts[:line]
+      #  @indent = opts[:indent]
+      #  @front  = opts[:front]
+      #  @mark   = opts[:mark]
+      #  @pad    = opts[:pad]
+      #  @till   = opts[:till]
+      #  @count  = opts[:count].to_i
+      #  @body   = opts[:body].strip
+      #  @post   = opts[:post]
+      #end
+
+      ## Add a tail line.
+      #def <<(line)
+      #  @tail << line
+      #end
+
+      #
+      #def to_s(result, cnt=nil)
+      #  if cnt
+      #    mark = marker.sub(/\+\d+/, "+#{cnt}")
+      #    "#{indent}#{front}#{mark}#{tail}\n" + result  + "\n" # TODO: there should be no front
+      #  elsif carrot?
+      #    b = tail.index('^') + 1
+      #    e = tail.index(/[<{]/) || - 1
+      #    m = tail[b...e]
+      #    i = front.index(m)
+      #    result = front[0...i] + result.sub('^','')
+      #    "#{indent}#{result}#{marker}#{tail}\n"
+      #  else
+      #    "#{indent}#{result}#{marker}#{tail}\n"
+      #  end
+      #end
+
+      # Is a carrot matcher?
+      def self.carrot?(render)
+        /^\s*\^/.match(render)
+      end
+
+    end#class Type
+
+  end#class Inline
+
+end#module Till
+