A Tiny Page

def

Testing page

syntax_test.js

syntax_test.rb

syntax_test.php

syntax_test.hs

syntax_test.sh

syntax_test.py

syntax_test.pl

) +{ + chomp; + $i = 0; + map { $max[$_->[1]] = $_->[0] if $_->[0] > ($max[$_->[1]] || 0) } + (map {[length $_, $i++]} split($delim)); +} +close F; + +print STDERR 'Field width: ', join(', ', @max), "\n"; +print STDERR join(' ', map {'-' x $_} @max); + +# second pass +open F, "<$ARGV[0]" or die; +while() + { + chomp; + $i = 0; + map { printf("%-$max[$_->[1]]s ", $_->[0]) } + (map {[$_, $i++]} split($delim)); + print "\n"; +} +close F; + +{% endhighlight %} + +

syntax_test.java

+{% highlight java %} +import java.util.Map; +import java.util.TreeSet; + +public class GetEnv { + /** + * let's test generics + * @param args the command line arguments + */ + public static void main(String[] args) { + // get a map of environment variables + Map env = System.getenv(); + // build a sorted set out of the keys and iterate + for(String k: new TreeSet(env.keySet())) { + System.out.printf("%s = %s\n", k, env.get(k)); + } + } } +{% endhighlight %} + +

syntax_test.c

+{% highlight c %} +#define UNICODE +#include + +int main(int argc, char **argv) { + int speed = 0, speed1 = 0, speed2 = 0; // 1-20 + printf("Set Mouse Speed by Maverick\n"); + + SystemParametersInfo(SPI_GETMOUSESPEED, 0, &speed, 0); + printf("Current speed: %2d\n", speed); + + if (argc == 1) return 0; + if (argc >= 2) sscanf(argv[1], "%d", &speed1); + if (argc >= 3) sscanf(argv[2], "%d", &speed2); + + if (argc == 2) // set speed to first value + speed = speed1; + else if (speed == speed1 || speed == speed2) // alternate + speed = speed1 + speed2 - speed; + else + speed = speed1; // start with first value + + SystemParametersInfo(SPI_SETMOUSESPEED, 0, speed, 0); + SystemParametersInfo(SPI_GETMOUSESPEED, 0, &speed, 0); + printf("New speed: %2d\n", speed); + return 0; +} + +{% endhighlight %} + diff --git a/source/test/syntax.markdown b/source/test/syntax.markdown deleted file mode 100644 index ec5bab50..00000000 --- a/source/test/syntax.markdown +++ /dev/null @@ -1,228 +0,0 @@ ---- -layout: default -title: Syntax Highlighting Debug ---- -

-Ruby -{% highlight ruby %} -def rebuild_site(relative) - puts ">>> Change Detected to: #{relative} <<<" - IO.popen('rake generate') do |io| - print(io.readpartial(512)) until io.eof? - end - puts '>>> Update Complete <<<' -end -{% endhighlight %} -

- -So that's a small example. What about a big one? - -

-Ruby -{% highlight ruby %} -require 'active_support/core_ext/array' -require 'active_support/core_ext/hash/except' -require 'active_support/core_ext/object/metaclass' - -module ActiveRecord - module NamedScope - extend ActiveSupport::Concern - - # All subclasses of ActiveRecord::Base have one named scope: - # * scoped - which allows for the creation of anonymous \scopes, on the fly: Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions) - # - # These anonymous \scopes tend to be useful when procedurally generating complex queries, where passing - # intermediate values (scopes) around as first-class objects is convenient. - # - # You can define a scope that applies to all finders using ActiveRecord::Base.default_scope. - included do - named_scope :scoped, lambda { |scope| scope } - end - - module ClassMethods - def scopes - read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {}) - end - - # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query, - # such as :conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions. - # - # class Shirt < ActiveRecord::Base - # named_scope :red, :conditions => {:color => 'red'} - # named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true] - # end - # - # The above calls to named_scope define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red, - # in effect, represents the query Shirt.find(:all, :conditions => {:color => 'red'}). - # - # Unlike Shirt.find(...), however, the object returned by Shirt.red is not an Array; it resembles the association object - # constructed by a has_many declaration. For instance, you can invoke Shirt.red.find(:first), Shirt.red.count, - # Shirt.red.find(:all, :conditions => {:size => 'small'}). Also, just - # as with the association objects, named \scopes act like an Array, implementing Enumerable; Shirt.red.each(&block), - # Shirt.red.first, and Shirt.red.inject(memo, &block) all behave as if Shirt.red really was an Array. - # - # These named \scopes are composable. For instance, Shirt.red.dry_clean_only will produce all shirts that are both red and dry clean only. - # Nested finds and calculations also work with these compositions: Shirt.red.dry_clean_only.count returns the number of garments - # for which these criteria obtain. Similarly with Shirt.red.dry_clean_only.average(:thread_count). - # - # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which the \scopes were defined. But they are also available to - # has_many associations. If, - # - # class Person < ActiveRecord::Base - # has_many :shirts - # end - # - # then elton.shirts.red.dry_clean_only will return all of Elton's red, dry clean - # only shirts. - # - # Named \scopes can also be procedural: - # - # class Shirt < ActiveRecord::Base - # named_scope :colored, lambda { |color| - # { :conditions => { :color => color } } - # } - # end - # - # In this example, Shirt.colored('puce') finds all puce shirts. - # - # Named \scopes can also have extensions, just as with has_many declarations: - # - # class Shirt < ActiveRecord::Base - # named_scope :red, :conditions => {:color => 'red'} do - # def dom_id - # 'red_shirts' - # end - # end - # end - # - # - # For testing complex named \scopes, you can examine the scoping options using the - # proxy_options method on the proxy itself. - # - # class Shirt < ActiveRecord::Base - # named_scope :colored, lambda { |color| - # { :conditions => { :color => color } } - # } - # end - # - # expected_options = { :conditions => { :colored => 'red' } } - # assert_equal expected_options, Shirt.colored('red').proxy_options - def named_scope(name, options = {}, &block) - name = name.to_sym - scopes[name] = lambda do |parent_scope, *args| - Scope.new(parent_scope, case options - when Hash - options - when Proc - options.call(*args) - end, &block) - end - metaclass.instance_eval do - define_method name do |*args| - scopes[name].call(self, *args) - end - end - end - end - - class Scope - attr_reader :proxy_scope, :proxy_options, :current_scoped_methods_when_defined - NON_DELEGATE_METHODS = %w(nil? send object_id class extend find size count sum average maximum minimum paginate first last empty? any? many? respond_to?).to_set - [].methods.each do |m| - unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s) - delegate m, :to => :proxy_found - end - end - - delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope - - def initialize(proxy_scope, options, &block) - options ||= {} - [options[:extend]].flatten.each { |extension| extend extension } if options[:extend] - extend Module.new(&block) if block_given? - unless Scope === proxy_scope - @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods) - end - @proxy_scope, @proxy_options = proxy_scope, options.except(:extend) - end - - def reload - load_found; self - end - - def first(*args) - if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash)) - proxy_found.first(*args) - else - find(:first, *args) - end - end - - def last(*args) - if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash)) - proxy_found.last(*args) - else - find(:last, *args) - end - end - - def size - @found ? @found.length : count - end - - def empty? - @found ? @found.empty? : count.zero? - end - - def respond_to?(method, include_private = false) - super || @proxy_scope.respond_to?(method, include_private) - end - - def any? - if block_given? - proxy_found.any? { |*block_args| yield(*block_args) } - else - !empty? - end - end - - # Returns true if the named scope has more than 1 matching record. - def many? - if block_given? - proxy_found.many? { |*block_args| yield(*block_args) } - else - size > 1 - end - end - - protected - def proxy_found - @found || load_found - end - - private - def method_missing(method, *args, &block) - if scopes.include?(method) - scopes[method].call(self, *args) - else - with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ? proxy_options[:conditions] : {}}, :reverse_merge) do - method = :new if method == :build - if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined) - with_scope current_scoped_methods_when_defined do - proxy_scope.send(method, *args, &block) - end - else - proxy_scope.send(method, *args, &block) - end - end - end - end - - def load_found - @found = find(:all) - end - end - end -end -{% endhighlight %} -

\ No newline at end of file -- cgit v1.2.1

gist_syntax_test.rb

syntax_test.diff

syntax_test.html

abc

def