mab 0.0.2 → 0.0.3

data/markaby/Rakefile

@@ -1,78 +0,0 @@
-require 'rake'
-require 'rspec/core/rake_task'
-require 'rake/testtask'
-require 'rake/clean'
-
-begin
-  require 'hanna/rdoctask'
-
-  Rake::RDocTask.new do |rdoc|
-    rdoc.rdoc_dir = 'doc/rdoc'
-    rdoc.options << '--line-numbers'
-    rdoc.rdoc_files.add(['README.rdoc', 'CHANGELOG.rdoc', 'lib/**/*.rb'])
-  end
-rescue LoadError
-  puts "Could not load hanna-rdoc.  Please install with mislav-hanna package"
-end
-
-task :default => [:spec, :test]
-
-Rake::TestTask.new(:test) do |t|
-  t.pattern = 'spec/markaby/*_test.rb'
-end
-
-RSpec::Core::RakeTask.new(:spec)
-
-begin
-  require 'jeweler'
-
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name          = "markaby"
-    gemspec.summary       = "Markup as Ruby, write HTML in your native Ruby tongue"
-    gemspec.description   = "Tim Fletcher and _why's ruby driven HTML templating system"
-    gemspec.email         = "scott@railsnewbie.com"
-    gemspec.homepage      = "http://markaby.github.com/markaby/"
-    gemspec.authors       = ["_why", "Tim Fletcher", "John Barton", "spox", "smtlaissezfaire"]
-    gemspec.add_dependency 'builder', '>=2.0.0'
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
-
-desc "List any Markaby specific warnings"
-task :warnings do
-  `ruby -w test/test_markaby.rb 2>&1`.split(/\n/).each do |line|
-    next unless line =~ /warning:/
-    next if line =~ /builder-/
-    puts line
-  end
-end
-
-desc "Start a Markaby-aware IRB session"
-task :irb do
-  sh 'irb -I lib -r markaby -r markaby/kernel_method'
-end
-
-namespace :gemspec do
-  task :commit do
-    sh "git add ."
-    sh "git commit -m 'Update gemspec'"
-  end
-end
-
-namespace :release do
-  task :patch => [:spec, "version:bump:patch", :update_gemspec, :rerdoc, :tag_release, :build, :push_tags]
-
-  task :update_gemspec => ["gemspec:generate", "gemspec:validate", "gemspec:commit"]
-  task :tag_release do
-    require File.dirname(__FILE__) + "/lib/markaby"
-    version = "v#{Markaby::VERSION}"
-    sh "git tag #{version}"
-  end
-
-  task :push_tags do
-    sh "git push --tags"
-  end
-end
-
-task :release => "release:patch"

data/markaby/VERSION

@@ -1 +0,0 @@
-0.7.2

data/markaby/garlic.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/lib/markaby/rails")
-
-garlic do
-  # this plugin
-  repo "markaby", :path => '.'
-
-  # other repos
-  repo "rails", :url => "git://github.com/rails/rails"
-
-  # target railses
-  RAILS_TAREGETS = Markaby::Rails::SUPPORTED_RAILS_VERSIONS.map do |version|
-    "v#{version}"
-  end
-
-  RAILS_TAREGETS.each do |rails|
-    # declare how to prepare, and run each CI target
-    target "Rails: #{rails}", :tree_ish => rails do
-      prepare do
-        plugin "markaby", :clone => true # so we can work in targets
-      end
-
-      run do
-        cd "vendor/plugins/markaby" do
-          sh "rake"
-        end
-      end
-    end
-  end
-end

data/markaby/init.rb

@@ -1,6 +0,0 @@
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
-
-require 'markaby'
-require 'markaby/rails'
-
-Markaby::Rails.load

data/markaby/lib/markaby.rb

@@ -1,30 +0,0 @@
-# = About lib/markaby.rb
-#
-# By requiring <tt>lib/markaby</tt>, you can load Markaby's dependency (the Builder library,)
-# as well as the full set of Markaby classes.
-#
-# For a full list of features and instructions, see the README.
-$:.unshift File.expand_path(File.dirname(__FILE__))
-
-# Markaby is a module containing all of the great Markaby classes that
-# do such an excellent job.
-#
-# * Markaby::Builder: the class for actually calling the Ruby methods
-#   which write the HTML.
-# * Markaby::CSSProxy: a class which adds element classes and IDs to
-#   elements when used within Markaby::Builder.
-# * Markaby::MetAid: metaprogramming helper methods.
-# * Markaby::Tags: lists the roles of various XHTML tags to help Builder
-#   use these tags as they are intended.
-# * Markaby::Template: a class for hooking Markaby into Rails as a
-#   proper templating language.
-module Markaby
-  version_file = File.expand_path(File.dirname(__FILE__) + "/../VERSION")
-  VERSION      = File.read(version_file).strip
-
-  class InvalidXhtmlError < StandardError; end
-end
-
-require 'builder' unless defined?(Builder)
-require 'markaby/builder'
-require 'markaby/cssproxy'

data/markaby/lib/markaby/builder.rb

@@ -1,314 +0,0 @@
-require 'markaby/tags'
-require 'markaby/builder_tags'
-
-module Markaby
-  RUBY_VERSION_ID = RUBY_VERSION.split(".").join.to_i
-
-  # The Markaby::Builder class is the central gear in the system.  When using
-  # from Ruby code, this is the only class you need to instantiate directly.
-  #
-  #   mab = Markaby::Builder.new
-  #   mab.html do
-  #     head { title "Boats.com" }
-  #     body do
-  #       h1 "Boats.com has great deals"
-  #       ul do
-  #         li "$49 for a canoe"
-  #         li "$39 for a raft"
-  #         li "$29 for a huge boot that floats and can fit 5 people"
-  #       end
-  #     end
-  #   end
-  #   puts mab.to_s
-  #
-  class Builder
-    include Markaby::BuilderTags
-
-    DEFAULT_OPTIONS = {
-      :indent                 => 0,
-      :output_helpers         => true,
-      :output_xml_instruction => true,
-      :output_meta_tag        => true,
-      :auto_validation        => true,
-      :tagset                 => Markaby::XHTMLTransitional,
-      :root_attributes => {
-        :xmlns      => 'http://www.w3.org/1999/xhtml',
-        :'xml:lang' => 'en',
-        :lang       => 'en'
-      }
-    }
-
-    @@options = DEFAULT_OPTIONS.dup
-
-    def self.restore_defaults!
-      @@options = DEFAULT_OPTIONS.dup
-    end
-
-    def self.set(option, value)
-      @@options[option] = value
-    end
-
-    def self.get(option)
-      @@options[option]
-    end
-
-    def self.ignored_helpers
-      @@ignored_helpers ||= []
-    end
-
-    def self.ignore_helpers(*helpers)
-      ignored_helpers.concat helpers
-    end
-
-    attr_accessor :output_helpers, :tagset
-
-    # Create a Markaby builder object.  Pass in a hash of variable assignments to
-    # +assigns+ which will be available as instance variables inside tag construction
-    # blocks.  If an object is passed in to +helper+, its methods will be available
-    # from those same blocks.
-    #
-    # Pass in a +block+ to new and the block will be evaluated.
-    #
-    #   mab = Markaby::Builder.new {
-    #     html do
-    #       body do
-    #         h1 "Matching Mole"
-    #       end
-    #     end
-    #   }
-    #
-    def initialize(assigns = {}, helper = nil, &block)
-      @streams = [Stream.new]
-      @assigns = assigns.dup
-      @_helper = helper
-      @used_ids = {}
-
-      @@options.each do |k, v|
-        instance_variable_set("@#{k}", @assigns.delete(k) || v)
-      end
-
-      @assigns.each do |k, v|
-        instance_variable_set("@#{k}", v)
-      end
-
-      if helper
-        helper.instance_variables.each do |iv|
-          instance_variable_set(iv, helper.instance_variable_get(iv))
-        end
-      end
-
-      @builder = XmlMarkup.new(:indent => @indent, :target => @streams.last)
-
-      text(capture(&block)) if block
-    end
-
-    def helper=(helper)
-      @_helper = helper
-    end
-
-    def metaclass(&block)
-      metaclass = class << self; self; end
-      metaclass.class_eval(&block)
-    end
-
-    private :metaclass
-
-    def locals=(locals)
-      locals.each do |key, value|
-        metaclass do
-          define_method key do
-            value
-          end
-        end
-      end
-    end
-
-    # Returns a string containing the HTML stream.  Internally, the stream is stored as an Array.
-    def to_s
-      @streams.last.to_s
-    end
-
-    # Write a +string+ to the HTML stream without escaping it.
-    def text(string)
-      @builder << string.to_s
-      nil
-    end
-    alias_method :<<, :text
-    alias_method :concat, :text
-
-    # Captures the HTML code built inside the +block+.  This is done by creating a new
-    # stream for the builder object, running the block and passing back its stream as a string.
-    #
-    #   >> Markaby::Builder.new.capture { h1 "TEST"; h2 "CAPTURE ME" }
-    #   => "<h1>TEST</h1><h2>CAPTURE ME</h2>"
-    #
-    def capture(&block)
-      @streams.push(@builder.target = Stream.new)
-      @builder.level += 1
-      str = instance_eval(&block)
-      str = @streams.last.join if @streams.last.any?
-      @streams.pop
-      @builder.level -= 1
-      @builder.target = @streams.last
-      str
-    end
-
-    # Create a tag named +tag+. Other than the first argument which is the tag name,
-    # the arguments are the same as the tags implemented via method_missing.
-    def tag!(tag, *args, &block)
-      ele_id = nil
-      if @auto_validation && @tagset
-        if !@tagset.tagset.has_key?(tag)
-          raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
-        elsif args.last.respond_to?(:to_hash)
-          attrs = args.last.to_hash
-
-          if @tagset.forms.include?(tag) && attrs[:id]
-            attrs[:name] ||= attrs[:id]
-          end
-
-          attrs.each do |k, v|
-            atname = k.to_s.downcase.intern
-            unless k =~ /:/ or @tagset.tagset[tag].include? atname
-              raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
-            end
-            if atname == :id
-              ele_id = v.to_s
-              if @used_ids.has_key? ele_id
-                raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
-              end
-            end
-            if AttrsBoolean.include? atname
-              if v
-                attrs[k] = atname.to_s
-              else
-                attrs.delete k
-              end
-            end
-          end
-        end
-      end
-
-      if block
-        str = capture(&block)
-        block = proc { text(str) }
-      end
-
-      f = fragment { @builder.tag!(tag, *args, &block) }
-      @used_ids[ele_id] = f if ele_id
-      f
-    end
-
-  private
-
-    # This method is used to intercept calls to helper methods and instance
-    # variables.  Here is the order of interception:
-    #
-    # * If +sym+ is a helper method, the helper method is called
-    #   and output to the stream.
-    # * If +sym+ is a Builder::XmlMarkup method, it is passed on to the builder object.
-    # * If +sym+ is also the name of an instance variable, the
-    #   value of the instance variable is returned.
-    # * If +sym+ has come this far and no +tagset+ is found, +sym+ and its arguments are passed to tag!
-    # * If a tagset is found, though, +NoMethodError+ is raised.
-    #
-    # method_missing used to be the lynchpin in Markaby, but it's no longer used to handle
-    # HTML tags.  See html_tag for that.
-    def method_missing(sym, *args, &block)
-      if @_helper.respond_to?(sym, true) && !self.class.ignored_helpers.include?(sym)
-        r = @_helper.send(sym, *args, &block)
-        if @output_helpers && r.respond_to?(:to_str)
-          fragment { @builder << r }
-        else
-          r
-        end
-      elsif @assigns.has_key?(sym)
-        @assigns[sym]
-      elsif @assigns.has_key?(stringy_key = sym.to_s)
-        # Rails' ActionView assigns hash has string keys for
-        # instance variables that are defined in the controller.
-        @assigns[stringy_key]
-      elsif instance_variables_for(self).include?(ivar = "@#{sym}".to_sym)
-        instance_variable_get(ivar)
-      elsif @_helper && instance_variables_for(@_helper).include?(ivar)
-        @_helper.instance_variable_get(ivar)
-      elsif instance_methods_for(::Builder::XmlMarkup).include?(sym)
-        @builder.__send__(sym, *args, &block)
-      elsif !@tagset
-        tag!(sym, *args, &block)
-      else
-        super
-      end
-    end
-
-    if RUBY_VERSION_ID >= 191
-      def instance_variables_for(obj)
-        obj.instance_variables
-      end
-
-      def instance_methods_for(obj)
-        obj.instance_methods
-      end
-    else
-      def instance_variables_for(obj)
-        obj.instance_variables.map { |var| var.to_sym }
-      end
-
-      def instance_methods_for(obj)
-        obj.instance_methods.map { |m| m.to_sym }
-      end
-    end
-
-    def fragment
-      stream = @streams.last
-      start = stream.length
-      yield
-      length = stream.length - start
-      Fragment.new(stream, start, length)
-    end
-  end
-
-  class Stream < Array
-    alias_method :to_s, :join
-  end
-
-  # Every tag method in Markaby returns a Fragment.  If any method gets called on the Fragment,
-  # the tag is removed from the Markaby stream and given back as a string.  Usually the fragment
-  # is never used, though, and the stream stays intact.
-  #
-  # For a more practical explanation, check out the README.
-  class Fragment < ::Builder::BlankSlate
-    def initialize(*args)
-      @stream, @start, @length = args
-      @transformed_stream = false
-    end
-
-    [:to_s, :inspect, :==].each do |method|
-      undef_method method if method_defined?(method)
-    end
-
-  private
-
-    def method_missing(*args, &block)
-      transform_stream unless transformed_stream?
-      @str.__send__(*args, &block)
-    end
-
-    def transform_stream
-      @transformed_stream = true
-
-      # We can't do @stream.slice!(@start, @length),
-      # as it would invalidate the @starts and @lengths of other Fragment instances.
-      @str = @stream[@start, @length].to_s
-      @stream[@start, @length] = [nil] * @length
-    end
-
-    def transformed_stream?
-      @transformed_stream
-    end
-  end
-
-  class XmlMarkup < ::Builder::XmlMarkup
-    attr_accessor :target, :level
-  end
-end