txprails 0.1.1

data/ext/txparse/txparse_lib.cpp

@@ -0,0 +1,191 @@
+#include "ruby.h"
+#include "txparse.h"
+
+//---------------------------------------------------------------------------
+const string TXPDictSpaces   = " \t\r\n";
+const string TXPDictWordLim  = " \t\r\n,<>/=";
+const string TXPDictSingleQuote = "'";
+const string TXPDictDoubleQuote = "\"";
+
+string txp_domain_str = "dmstk";
+
+//---------------------------------------------------------------------------
+static bool txp_isspace(string::const_iterator iter)
+{
+    return find(TXPDictSpaces.begin(), TXPDictSpaces.end(), *iter) != TXPDictSpaces.end();
+}
+
+//---------------------------------------------------------------------------
+static bool txp_valid_chars(
+		string::const_iterator iter,
+		string::const_iterator end
+		)
+{
+	if (*iter == '/') { iter++; end++; }
+	for (; iter != end; ++iter) {
+		if (::isspace(*iter)) return false;
+		if (*iter == ':') return true;
+		if (!::isalpha(*iter)) return false;
+	}
+	return false; // No se encontró los dos puntos...
+}
+
+//---------------------------------------------------------------------------
+string::const_iterator txp_find_tag(
+		string::const_iterator iter,
+		string::const_iterator end
+		)
+{
+	// Encontramos un TAG de plantilla cuando tengamos "<" + [a-z]{3} + ":"
+	// O también cuando tengamos "</" ya que es de cierre...
+    while (iter != end) {
+        if ((*iter == '<') && (end - iter > 5) && txp_valid_chars(iter+1, iter+7))
+			return iter;
+        ++iter;
+    }
+	return iter;
+}
+
+//---------------------------------------------------------------------------
+string::const_iterator txp_find_close(
+		string::const_iterator iter,
+		string::const_iterator end
+		)
+{
+	// Encontramos un final de TAG cuando tengamos ">"
+	for (; iter != end; ++iter) {
+		if (*iter == '>') return iter+1;
+	}
+	return iter;
+}
+
+//---------------------------------------------------------------------------
+string::const_iterator txp_find_par(
+		string::const_iterator begin,
+		string::const_iterator end,
+		VALUE tag
+		)
+{
+	// TODO:
+	// Tenemos que hacer el mismo recorrido a partir de "begin" que en el 
+	// bucle de parsing, pero esta vez sólo para encontrar un tag coincidente
+	// con el que nos pasan... Todo esto no es más que una prueba, habría que
+	// hacer un algoritmo más "robusto" para esto (Por ejemplo con pilas para
+	// encontrar un tag balanceado, ahora no pueden estar anidados.)
+	
+	string::const_iterator old;
+
+	while (begin != end) {
+		begin = txp_find_tag(begin, end);
+		if (begin != end) {
+			// Estamos en un tag...
+			old = begin;
+			begin = txp_find_close(begin, end);
+			if (begin != end) {
+				VALUE tag_txt = rb_str_new2(string(old, begin).c_str());
+				VALUE new_tag = rb_class_new_instance(1, &tag_txt, rb_const_get(mTXParse, rb_intern("Tag")));
+/*
+				printf(":::: SEARCHING PAR (D:'%s' vs '%s', N:'%s' vs. '%s')\n"
+							, RSTRING(rb_iv_get(tag, "@domain"))->ptr
+							, RSTRING(rb_iv_get(new_tag, "@domain"))->ptr
+							, RSTRING(rb_iv_get(tag, "@name"))->ptr
+							, RSTRING(rb_iv_get(new_tag, "@name"))->ptr
+						);
+*/
+
+				// Vale, comprobamos que el tag se llama igual...
+				if (!rb_str_cmp(rb_iv_get(tag, "@domain"), rb_iv_get(new_tag, "@domain")) &&
+					!rb_str_cmp(rb_iv_get(tag, "@name"), rb_iv_get(new_tag, "@name"))) {
+//						printf(":::: FOUND!!!\n");
+
+						// Es el mismo TAG... ¿Es de cierre?
+						if (rb_iv_get(new_tag, "@is_close") == Qtrue) {
+//							printf(":::: New Tag is CLOSE\n");
+//							printf(":::: DBG: [%s]\n", string(old, end).c_str());
+							return old;
+						}
+				}
+			}
+		}
+	}
+	return end;	// What else?
+}
+
+
+#define	DEBUG_POS(str, pos) \
+{\
+	string strdebug = string(str.size(), ' '); \
+	strdebug[pos] = '$'; \
+	printf("|%s|\n", str.c_str()); \
+	printf("|%s|\n", strdebug.c_str()); \
+}
+
+//---------------------------------------------------------------------------
+void txp_parse_tag(const string tag, string &domain, string &name, map<string, string> &attrs, bool &close)
+{
+	string::size_type pos = 0, pos2;
+
+	if ((tag.size() == 0) || (tag[pos++] != '<')) {
+		rb_raise(rb_eSyntaxError, "Tag should begin with '<'");
+		// rb_raise no retorna...
+	}
+
+	if (tag[pos] == '/') {
+		close = true;
+		pos++;
+	}
+
+	pos2 = tag.find_first_of(":/> \t\r\n", pos);
+	if ((pos2 == string::npos) || (tag[pos2] != ':')) {
+		rb_warn("TAG Should have a 'domain'. Assuming 'dmstk'");
+		// rb_raise(rb_eSyntaxError, "Tag should have a domain.");
+		domain = "dmstk";
+		name = string(tag, pos, pos2 - pos);
+	} else {
+		domain = string(tag, pos, pos2 - pos);
+		pos = pos2 + 1;
+		pos2 = tag.find_first_of(":/> \t\r\n", pos);
+		name = string(tag, pos, pos2 - pos);
+	}
+	
+	// Si soy tag de cierre, no debo tener attributos.
+	if (close) return;
+
+	// Parseado el dominio y el nombre, saltamos a los attributos...
+	pos = tag.find_first_not_of(" \t\r\n", pos2);
+	if ((pos == string::npos) || (pos == '>')) return;
+
+	while ((pos != string::npos) && (tag[pos] != '>')) {
+		// Caso especial del tag de autocierre y el final de tag '>'
+		if ((tag[pos] == '/') && (tag[pos+1] == '>')) {
+			close = true;	// autoclose ??
+			pos = string::npos;
+			break;
+		}
+		
+		pos2 = tag.find_first_of(" \t\r\n,<>/=", pos);
+		string attrname = string(tag, pos, pos2 - pos);
+		string attrval  = "";
+
+		pos2 = tag.find_first_not_of(" \t\r\n", pos2);
+		if ((pos2 != string::npos) && (tag[pos2]=='=')) {
+			// Parseando valor de atributo
+			pos2 = tag.find_first_not_of(" \t\r\n", pos2+1);
+
+			switch (tag[pos2]) {
+				case '\'': pos = pos2+1; pos2 = tag.find_first_of("'", pos); break;
+				case '"':  pos = pos2+1; pos2 = tag.find_first_of("\"", pos); break;
+				default:   pos = pos2; pos2 = tag.find_first_of(" \t\r\n"); break;
+			}
+			attrval = string(tag, pos, pos2 - pos);
+		} else {
+			// Atributo sin valores!! Asumimos -->  nombre="nombre"
+			attrval = attrname;
+		}
+
+		attrs[attrname] = attrval;
+
+		// Tenemos que dejar "pos" en el siguiente atributo...
+		pos = tag.find_first_not_of(" \t\r\n", pos2+1);
+	}
+}

data/ext/txparse/txparse_lib.h

@@ -0,0 +1,17 @@
+#ifndef	TXPARSE_LIB
+#define TXPARSE_LIB
+
+#include <string>
+#include <map>
+
+using namespace std;
+
+extern string txp_domain_str;
+
+//---------------------------------------------------------------------------
+string::const_iterator txp_find_tag(string::const_iterator iter, string::const_iterator end);
+string::const_iterator txp_find_close(string::const_iterator iter, string::const_iterator end);
+string::const_iterator txp_find_par(string::const_iterator begin, string::const_iterator end, VALUE tag);
+void txp_parse_tag(const string tag, string &domain, string &name, map<string, string> &attrs, bool &close);
+
+#endif

data/ext/txparse/txparse_tag.cpp

@@ -0,0 +1,109 @@
+#include "ruby.h"
+#include "txparse.h"
+
+extern "C" VALUE tag_initialize(VALUE self, VALUE orig)
+{
+	string domain, name;
+	map<string, string> attrs;
+	bool is_close = false;
+	VALUE attr_hash = rb_hash_new();
+
+	rb_check_type(orig, T_STRING);
+	txp_parse_tag(string(RSTRING(orig)->ptr), domain, name, attrs, is_close);
+
+/*
+printf("PARSE-TAG DBG: ORIG='%s'\n", RSTRING(orig)->ptr);
+printf("               DOMAIN='%s', NAME='%s'\n", domain.c_str(), name.c_str());
+printf("               ATTRS(num)='%d', CLOSED='%c'\n", (int)attrs.size(), is_close ? 'Y' : 'N');
+*/
+
+	if (attrs.size()) {
+		for (map<string, string>::const_iterator iter = attrs.begin()
+			; iter != attrs.end()
+			; ++iter)
+		{
+			rb_hash_aset(attr_hash, rb_str_new2((*iter).first.c_str()), rb_str_new2((*iter).second.c_str()));
+		}
+	}
+
+	rb_iv_set(self, "@name", rb_str_new2(name.c_str()));
+	rb_iv_set(self, "@domain", rb_str_new2(domain.c_str()));
+	rb_iv_set(self, "@is_close", is_close ? Qtrue : Qfalse);
+	rb_iv_set(self, "@attr", attr_hash);
+	rb_iv_set(self, "@orig", orig);
+	return self;
+}
+
+extern "C" VALUE tag_name(VALUE self)
+{
+	return rb_iv_get(self, "@name");
+}
+
+extern "C" VALUE tag_name_set(VALUE self, VALUE new_name)
+{
+	return rb_iv_set(self, "@name", new_name);
+}
+
+
+extern "C" VALUE tag_domain(VALUE self)
+{
+	return rb_iv_get(self, "@domain");
+}
+
+extern "C" VALUE tag_domain_set(VALUE self, VALUE new_domain)
+{
+	return rb_iv_set(self, "@domain", new_domain);
+}
+
+extern "C" VALUE tag_thing(VALUE self)
+{
+	return rb_iv_get(self, "@thing");
+}
+
+extern "C" VALUE tag_thing_set(VALUE self, VALUE new_thing)
+{
+	return rb_iv_set(self, "@thing", new_thing);
+}
+
+extern "C" VALUE tag_attributes(VALUE self)
+{
+	return rb_iv_get(self, "@attr");
+}
+
+
+
+extern "C" VALUE tag_is_close(VALUE self)
+{
+	return rb_iv_get(self, "@is_close");
+}
+
+extern "C" VALUE tag_orig(VALUE self)
+{
+	return rb_iv_get(self, "@orig");
+}
+
+
+
+
+VALUE mTXParseTag = Qnil;
+void Init_TXParseTag()
+{
+//	VALUE TXParse_Module = rb_define_module("TXParse");
+	mTXParseTag = rb_define_class_under(mTXParse, "Tag", rb_cObject);
+
+	rb_define_method(mTXParseTag, "initialize", RUBY_METHOD_FUNC(tag_initialize), 1);
+
+	rb_define_method(mTXParseTag, "name", RUBY_METHOD_FUNC(tag_name), 0);
+	rb_define_method(mTXParseTag, "name=", RUBY_METHOD_FUNC(tag_name_set), 1);
+
+	rb_define_method(mTXParseTag, "domain", RUBY_METHOD_FUNC(tag_domain), 0);
+	rb_define_method(mTXParseTag, "domain=", RUBY_METHOD_FUNC(tag_domain_set), 1);
+
+	rb_define_method(mTXParseTag, "thing", RUBY_METHOD_FUNC(tag_thing), 0);
+	rb_define_method(mTXParseTag, "thing=", RUBY_METHOD_FUNC(tag_thing_set), 1);
+
+	rb_define_method(mTXParseTag, "attr", RUBY_METHOD_FUNC(tag_attributes), 0);
+
+	rb_define_method(mTXParseTag, "close?", RUBY_METHOD_FUNC(tag_is_close), 0);
+	rb_define_method(mTXParseTag, "orig", RUBY_METHOD_FUNC(tag_orig), 0);
+}

data/ext/txparse/txparse_tag.h

@@ -0,0 +1,7 @@
+#ifndef	TXPARSE_TAG
+#define TXPARSE_TAG
+
+extern VALUE mTXParseTag;
+void Init_TXParseTag();
+
+#endif

data/lib/init_rails.rb

@@ -0,0 +1,16 @@
+begin
+  require File.join(File.dirname(__FILE__), 'txprails') # From here
+rescue LoadError
+  begin
+    require 'txprails' # From gem
+  rescue LoadError => e
+    # gems:install may be run to install TXPRails with the skeleton plugin
+    # but not the gem itself installed.
+    # Don't die if this is the case.
+    raise e unless defined?(Rake) && Rake.application.top_level_tasks.include?('gems:install')
+  end
+end
+
+# Load TXPRails.
+# TXPRails may be undefined if we're running gems:install.
+TXPRails.init_rails if defined?(TXPRails)

data/lib/txprails/commands.rb

@@ -0,0 +1,88 @@
+require 'optparse'
+require 'fileutils'
+
+module TXPRails
+  # This module handles miscelaneous command line utilities
+  class Commands
+    # @param args [Array<String>] The command-line arguments
+    def initialize(args)
+      @args = args
+      @options = {}
+      @options[:requires] = []    # ??
+      @options[:load_paths] = []  # ??
+    end
+
+    # Parses the command-line arguments and runs the executable.
+    # Calls `Kernel#exit` at the end, so it never returns.
+    def parse!
+      begin
+        @opts = OptionParser.new(&method(:set_opts))
+        @opts.parse!(@args)
+        @options
+      rescue Exception => e
+        raise e if e.is_a?(SystemExit)
+
+        $stderr.puts e.message
+        exit 1
+      end
+      exit 0
+    end
+
+    # @return [String] A description of the executable
+    def to_s
+      @opts.to_s
+    end
+
+    protected
+
+    # Tells optparse how to parse the arguments
+    # available for all executables.
+    #
+    # This is meant to be overridden by subclasses
+    # so they can add their own options.
+    #
+    # @param opts [OptionParser]
+    def set_opts(opts)
+      opts.on_tail("-?", "-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+
+      opts.on_tail("-v", "--version", "Print version") do
+        puts("TXPRails #{::TXPRails.version[:string]}")
+        exit
+      end
+
+      opts.on('--rails RAILS_DIR', "Install TXPRails from the Gem to a Rails project") do |dir|
+        original_dir = dir
+        dir = File.join(dir, 'vendor', 'plugins')
+        unless File.exists?(dir)
+          puts "Directory #{dir} doesn't exist"
+          exit
+        end
+
+        dir = File.join(dir, 'txprails')
+        if File.exists?(dir)
+          print "Directory #{dir} already exists, overwrite [y/N]? "
+          exit if gets !~ /y/i
+          FileUtils.rm_rf(dir)
+        end
+
+        begin
+          Dir.mkdir(dir)
+        rescue SystemCallError
+          puts "Cannot create #{dir}"
+          exit
+        end
+
+        File.open(File.join(dir, 'init.rb'), 'w') do |file|
+          file << File.read(File.dirname(__FILE__) + "/../init_rails.rb")
+        end
+
+        puts "Haml plugin added to #{original_dir}"
+        exit
+      end
+    end
+
+  end
+end

data/lib/txprails/template.rb

@@ -0,0 +1,29 @@
+# Simple template initialization code
+# Borrowed ideas from Haml, but VERY much simplyfied
+# WARNING: We choose to use the plugin approach, so NO RAILS < 2.1.0 compatibility!
+
+module TXPRails
+
+  class TXPTemplateHandler < TXPRails::Util.av_template_class(:Handler)
+    include TXP
+
+    def initialize(view)
+      @view = view
+    end
+    
+    def render(template, local_assigns = {})
+      parse(template.source)
+    end
+    
+    def compilable?
+      false
+    end
+  end
+end
+
+
+if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+  ActionView::Template
+else
+  ActionView::Base
+end.register_template_handler(:txp, TXPRails::TXPTemplateHandler)

data/lib/txprails/util.rb

@@ -0,0 +1,44 @@
+module TXPRails
+  # A module containing various useful functions.
+  module Util
+    extend self
+
+    # An array of ints representing the Ruby version number.
+    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
+
+    # Returns the path of a file relative to the Haml root directory.
+    #
+    # @param file [String] The filename relative to the Haml root
+    # @return [String] The filename relative to the the working directory
+    def scope(file)
+      File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
+    end
+
+    ## Cross Rails Version Compatibility
+
+    # Returns the root of the Rails application,
+    # if this is running in a Rails context.
+    # Returns `nil` if no such root is defined.
+    #
+    # @return [String, nil]
+    def rails_root
+      return Rails.root.to_s if defined?(Rails.root)
+      return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+      return nil
+    end
+
+    # Returns an ActionView::Template* class.
+    # In pre-3.0 versions of Rails, most of these classes
+    # were of the form `ActionView::TemplateFoo`,
+    # while afterwards they were of the form `ActionView::Template::Foo`.
+    #
+    # @param name [#to_s] The name of the class to get.
+    #   For example, `:Error` will return `ActionView::TemplateError`
+    #   or `ActionView::Template::Error`.
+    def av_template_class(name)
+      return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
+      return ActionView::Template.const_get(name.to_s)
+    end
+
+  end
+end

data/lib/txprails/version.rb

@@ -0,0 +1,64 @@
+require 'txprails/util'
+
+module TXPRails
+  # Handles TXPRails version-reporting.
+  # TXPRails not only reports the standard three version numbers,
+  # but its Git revision hash as well,
+  # if it was installed from Git.
+  module Version
+    include TXPRails::Util
+
+    # Returns a hash representing the version of TXPRails.
+    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
+    # The `:name` key has the name of the version.
+    # The `:string` key contains a human-readable string representation of the version.
+    # The `:number` key is the major, minor, and teeny keys separated by periods.
+    # If TXPRails is checked out from Git, the `:rev` key will have the revision hash.
+    # For example:
+    #
+    #     {
+    #       :string => "2.1.0.9616393",
+    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
+    #       :number => "2.1.0",
+    #       :major  => 2, :minor => 1, :teeny => 0
+    #     }
+    #
+    # @return [{Symbol => String/Fixnum}] The version hash
+    def version
+      return @@version if defined?(@@version)
+
+      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
+      name = File.read(scope('VERSION_NAME')).strip
+      @@version = {
+        :major => numbers[0],
+        :minor => numbers[1],
+        :teeny => numbers[2],
+        :name => name
+      }
+      @@version[:number] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
+      @@version[:string] = @@version[:number].dup
+
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
+      end
+
+      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+
+      if rev
+        @@version[:rev] = rev
+        unless rev[0] == ?(
+          @@version[:string] << "." << rev[0...7]
+        end
+        @@version[:string] << " (#{name})"
+      end
+
+      @@version
+    end
+  end
+end

data/lib/txprails.rb

@@ -0,0 +1,44 @@
+require 'txprails/txparse'
+require 'txprails/version'
+
+module TXPRails
+  extend TXPRails::Version
+  
+  # A string representing the version of TXPRails.
+  # A more fine-grained representation is available from TXPRails.version.
+  VERSION = version[:string] unless defined?(TXPRails::VERSION)
+
+  # Initializes TXPRails for Rails.
+  #
+  # This method is called by `init.rb`,
+  # which is run by Rails on startup.
+  # We use it rather than putting stuff straight into `init.rb`
+  # so we can change the initialization behavior
+  # without modifying the file itself.
+  #
+  def self.init_rails
+    %w[txprails/template].each {|f| require f}
+  end
+end
+
+require 'txprails/util'
+
+module TXP
+  include TXParse
+  
+  def txp_doc(tag)
+    "<!DOCTYPE html>"
+  end
+
+  def txp_content(tag)
+    if content_for_layout = @view.instance_variable_get("@content_for_layout")
+      parse(content_for_layout)
+    end
+  end
+
+  def txp_include(tag)
+    @view.render :partial => tag.attr["name"]
+  end
+
+#  self.extend self
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'txprails'
+
+class Test::Unit::TestCase
+end

data/test/test_txprails.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestTxprails < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end