Remarkably 0.4.0 → 0.5.0

data/lib/remarkably.rb

@@ -1,89 +1,62 @@
 module Remarkably
-  def method_missing(sym, *args, &block)
-    hash = args.last.is_a?(Hash) ? args.pop : {}
-    tag!(sym, args, hash, &block)
-  end
 
-  def tag_xml!( tag, inline, attributes, &block )
-    tag_attributes =
-      attributes.inject([]){|s,(k,v)| s << %{#{k.to_s.downcase}="#{v}"} }
+  module Base
 
-    @remarkably << ["<#{tag}", tag_attributes].flatten.grep(/\S/).join(' ')
+    class Engine
+      def initialize *args, &block
+        clear!
+        self.instance_eval( &block ) if block_given?
+      end
 
-    if block_given? or not inline.empty?
-      @remarkably << ">"
-      @remarkably_method = :css if @remarkably_method == :xml and tag == "style"
-      block.call if block_given?
-      if @remarkably_method == :css and tag == "style"
-        @remarkably_method = :xml
-        @remarkably << "\n"
+      def missing_method(sym, context, *args, &block)
+        @context = context
+        hash = args.last.is_a?(Hash) ? args.pop : {}
+        if methods.index( sym.to_s )
+          self.send( sym, args, hash, &block )
+        else
+          method!(sym, args, hash, &block)
+        end
+      end
+
+      def method_missing(sym, *args, &block)
+        missing_method( sym, self, *args, &block )
+      end
+
+      def clear!
+        @output = ''
+      end
+
+      def method! sym, args, hash, &block
+      end
+
+      def to_s
+        result = @output
+        clear!
+        result
       end
-      @remarkably << "#{inline.join}</#{tag}>"
-    else
-      @remarkably << "/>"
-    end
-  end
 
-  def tag_css!( tag, inline, attributes, &block )
-    @remarkably_method = :css_inner
-    if block_given?
-      @remarkably << "\n "
-      tag_css_inner!( tag, inline, attributes, &block )
-      @remarkably << "}"
     end
-    @remarkably_method = :css
-  end
 
-  def inline_style &block
-    current_remarkably = @remarkably
-    @remarkably_method = :css_inner
-    @remarkably = ''
-    block.call if block_given?
-    result = @remarkably
-    @remarkably_method = :xml
-    @remarkably = current_remarkably
-    result
   end
 
-  def tag_css_inner!( tag, inline, attributes, &block )
-    if block_given?
-      @remarkably.chop!
-      @remarkably << "#{tag}#{inline.join}"
-      @remarkably << ".#{attributes[:class]}" if attributes.has_key?( :class )
-      @remarkably << "##{attributes[:id]}" if attributes.has_key?( :id )
-      @remarkably << ":#{attributes[:pseudo]}" if attributes.has_key?( :pseudo )
-      @remarkably << " {"
-      block.call
-    else
-      tag.gsub!('_','-')
-      @remarkably << "#{tag}:#{inline.join(' ')};"
+  module Common
+
+    def method_missing(sym, *args, &block)
+      @remarkably_engine ||= eval("Engines::#{Engines::constants[0]}.new")
+      @remarkably_engine.send( :missing_method, sym, self, *args, &block )
     end
-  end
 
-  def tag!(tag, inline=[], attributes={}, &block)
-    tag = tag.to_s.downcase
-    inline = [inline] if inline.class != Array
-    @remarkably ||= ''
-    @remarkably_method ||= :xml
-
-    case @remarkably_method
-    when :xml       then tag_xml!( tag, inline, attributes, &block )
-    when :css       then tag_css!( tag, inline, attributes, &block )
-    when :css_inner then tag_css_inner!( tag, inline, attributes, &block )
-    else raise "Unknown remarkably method type '#{@remarkably_method}'"
+    def remarkably_engine= engine
+      @remarkably_engine = engine
     end
 
-    self
-  end
+    def remarkably_engine
+      @remarkably_engine
+    end
 
-  def text content
-    @remarkably << content
-    self
   end
 
-  def to_s
-    result = @remarkably
-    @remarkably = nil
-    result
+  module Engines
   end
+
 end

data/lib/remarkably/engines/css.rb

@@ -0,0 +1,47 @@
+require "#{File::dirname(__FILE__)}/../../remarkably"
+
+module Remarkably
+  module Engines
+    class CSS < Base::Engine
+      def method! sym, args, hash, &block
+        sym = sym.to_s.downcase
+
+        if block_given?
+          current_prefix = @css_prefix
+          @css_prefix = (@css_prefix+" #{sym}#{args.map{|a|a.to_s}.join}").strip
+          @css_depth+=1
+          @css_prefix_rendered=false
+          block.call
+          @css_depth-=1
+          @css_prefix = current_prefix
+        else
+          unless @css_prefix_rendered
+            unless @css_first_use
+              @output.chop!
+              @output << "}"
+            end
+            @output << "\n#{@css_prefix} {"
+            @css_prefix_rendered = true
+            @css_first_use = false
+          end
+          @output << "#{sym.gsub('_','-')}:#{args.map{|a|a.to_s}.join(' ')};"
+        end
+        self
+      end
+
+      def to_s
+        "#{super.chop}}".strip+"\n"
+      end
+
+      def clear!
+        super
+        @css_prefix=''
+        @css_depth=0
+        @css_prefix_rendered=false
+        @css_first_use=true
+      end
+
+    end
+  end
+end
+

data/lib/remarkably/engines/css/helpers.rb

@@ -0,0 +1,7 @@
+[ Fixnum, Float ].each do |extend_class|
+  extend_class.class_eval do
+    %w{em ex cm in mm pt pc px}.each do |unit|
+      define_method( unit ) {"#{self}#{unit}"}
+    end
+  end
+end

data/lib/remarkably/engines/html.rb

@@ -0,0 +1,24 @@
+require "#{File::dirname(__FILE__)}/../../remarkably"
+require "#{File::dirname(__FILE__)}/xml"
+require "#{File::dirname(__FILE__)}/css"
+
+module Remarkably
+  module Engines
+    class HTML < XML
+      def initialize
+        super
+        @css_engine = Engines::CSS.new
+      end
+      def style args, hash, &block
+        if block_given?
+          @css_engine.clear!
+          @context.remarkably_engine = @css_engine
+          block.call
+          @context.remarkably_engine = self
+          args = ["\n#{@css_engine}"]+args
+        end
+        method!( :style, args, hash )
+      end
+    end
+  end
+end

data/lib/remarkably/engines/xml.rb

@@ -0,0 +1,33 @@
+require "#{File::dirname(__FILE__)}/../../remarkably"
+
+module Remarkably
+  module Engines
+    class XML < Base::Engine
+
+      def method! sym, args, hash, &block
+        sym = sym.to_s.downcase
+
+        tag_attributes =
+          hash.inject([]){|s,(k,v)| s << %{#{k.to_s.downcase}="#{v}"} }
+
+        @output << ["<#{sym}", tag_attributes].flatten.grep(/\S/).join(' ')
+
+        if block_given? or not args.empty?
+          @output << ">"
+          block.call if block_given?
+          @output << "#{args.join}</#{sym}>"
+        else
+          @output << "/>"
+        end
+
+        self
+      end
+
+      def text args, hash, &block
+        @output << args.join
+        self
+      end
+
+    end
+  end
+end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.3
 specification_version: 1
 name: Remarkably
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
-date: 2007-05-16 00:00:00 +02:00
+  version: 0.5.0
+date: 2007-05-24 00:00:00 +02:00
 summary: Remarkably is a very tiny Markaby-like XML builder
 require_paths: 
 - lib
@@ -29,7 +29,14 @@ post_install_message:
 authors: 
 - Clive Crous
 files: 
+- lib/remarkably
 - lib/remarkably.rb
+- lib/remarkably/engines
+- lib/remarkably/engines/css
+- lib/remarkably/engines/xml.rb
+- lib/remarkably/engines/html.rb
+- lib/remarkably/engines/css.rb
+- lib/remarkably/engines/css/helpers.rb
 test_files: []
 
 rdoc_options: []