ragmaanir

Grammy is a very small recursive descent parser generator framework written in ruby. It has several similarities with boost::spirit.

Short example: g = Grammy.define :letters do rule lower: 'a'..'z' rule upper: 'A'..'Z' rule letter: :lower | :upper start word: +:letter end

You can use the defined grammar to parse strings:

result = g.parse("ALongWord") result.full_match? #=> true result.to_image("test") # creates a .png with graphviz, graphviz is required for that

An example image (not for this grammar):

Grammy supports:

• Most EBNF features: Sequences, Repetition, Alternatives, Optional rules
• Shortcut for lists: list and list?
• Skipping of characters: comments, whitespaces between words
• Generation of an AST. Most unused tokens can be removed automatically.
• AST can be written to an image file with help of graphviz.

You can get grammy at github: Grammy on github

There is also a more detailed description there.

This is an idea i came up with during analyzing problems while designing software.

A specific software-design has/causes several problems. Those problems have zero or more (alternative) solutions. These solutions are basically changes to the previous software design that caused the problem. The new software design that solves one or more problems of the initial design can again cause problems, but the problem that was solved with the solution wont be caused (otherwise the solution was not a real solution for the problem).

An example for a problem-graph:

So, a problem has several *alternative* solutions and a solution causes several problems (at once - they are not alternatives).

Dilemma

A cyclic problem-solution situation i call "dilemma", because it cant be solved by a specific solution:

Problem A can be solved with Solution A, which causes problem B, which in turn can be solved by the solution B, which causes problem A. You either solve A with solution A or B with solution B, but you cant solve both.

This does not imply that those problems cant be solved. There might be an alternative solution A2 (which has not been discovered yet) to solution A which does not cause problem B. But for this problem graph you can say: "Solving problem A with solution A leads into a dilemma".

Extensions

Weights

The problem graph idea can be extended: You can assign weights to the arrows. Without weights the causalities can be interpreted as:

• "The problem P is completely solved by the solution S"
• "The solution S causes exactly the problems P1 .. Pn"

With weights added it can be interpreted like this:

• "The problem P is weakly solved by solution S"
• "The solution S strongly causes problem P1 and weakly causes problem P2"

With these weights you can model non-exact problem relations like:

• "Spamming can be strongly reduced by introducing captchas"
• ..

Colors

The problems can be weighted (colored) too, so that you can say "problem X is much more costly than problem Y".

This can easily be extended (eg design algorithms that find optimal solutions for a problem graph etc) but at the moment im too busy.

Just recently i switched from windows XP to ubuntu 9.04. I had some problems (Ubuntu freezes when connecting to WLAN) with my wlan drivers (DLink DWA 547) but after installing the compat-wireless package it worked. But its slower and more unstable than on windows. (After upgrading ubuntu and recompiling the package WLAN works as good as on windows). I tried to install ruby 1.9.1 on ubuntu. After several hours of reading articles and googling i put together these install instructions: sudo apt-get install build-essential sudo aptitude install zlib1g sudo aptitude install zlib1g-dev RUBY_FILE = ruby-1.9.1-p243 RUBY_SRC = /usr/local/src/$RUBY_FILE cd /usr/local/src sudo wget ftp://ftp.ruby-lang.org/pub/ruby/1.9/$RUBY_FILE.tar.bz2 sudo tar xvf $RUBY_FILE.tar.bz2 cd $RUBY_SRC # maybe try --disable-pthread : http://timetobleed.com/fix-a-bug-in-rubys-configurein-and-get-a-30-performance-boost/ # several more options available RUBY_OPTIONS="--enable-shared --disable-install-doc" sudo ./configure $RUBY_OPTIONS sudo make && make install Test if the installation worked: $ ruby -v ruby 1.9.1p243 (2009-07-16 revision 24175) [x86_64-linux] Compile readline to get arrow keys support in IRB: # install readline for irb (arrow keys) sudo apt-get install libreadline5 libreadline5-dev cd $RUBY_SRC/ext/readline sudo ruby extconf.rb sudo make sudo make install cd ~ Now ruby 1.9.1 without valgrind is installed. Next install valgrind: VALGRIND_FILE = valgrind-3.4.1 cd /usr/local/src sudo wget http://valgrind.org/downloads/$VALGRIND_FILE.tar.bz2 sudo tar xvf $VALGRIND_FILE.tar.bz2 cd $VALGRIND_FILE sudo ./configure sudo make # make check sudo make install cd ~ Now setup another ruby installation with valgrind support. cd $RUBY_SRC sudo ./configure $RUBY_OPTIONS --with-valgrind --prefix=/opt/ruby-debug sudo make sudo make install cd ~ Then add some handy shortcuts: ln -s /opt/ruby-debug/bin/ruby /usr/local/bin/ruby-debug ln -s /opt/ruby-debug/bin/gem /usr/local/bin/gem-debug For more information see:

• Ruby 1.9.1 installation
• Valgrind and Ruby
• Ubuntu 9.04: Installing Ruby 1.9 with RubyGems from Source
• Compiling Ruby, RubyGems and Rails on Ubuntu
• How to make arrow keys working in irb in Linux/Ubuntu

UPDATE: Added --enable-shared to RUBY_OPTIONS

Because i am a bit paranoid i sometimes think about protecting my ROR-sourcecode. I came up with this idea:

* Encrypt all files (models,controllers,helpers,views,css,...) with a secret key.
* Upload the encrypted files on your server
* Put the key in a file and upload the file to config/
* When the rails app starts, load the key into memory and delete(!) the key file
* Decrypt files (in memory) of your app when they are loaded

An attacker that got access to the filesystem can't just copy the source since it is encrypted. One problem might be this:
The attacker got write access to the FS and creates a .rb somewhere in a loaded gem or in the rails app. Then he might be able to read out the key and decrypt the source files.

The best way i know to protect the source is to use JRuby and compile the rails app to a jar.

Mysql has a special 'INSERT ... ON DUPLICATE KEY UPDATE' statement which can be used for some models like e.g. ratings. Instead of something similar to this:
if m = Model.find(...) m.update else m = Model.new(params) m.save! end
You can just do this: m = Model.new(params) m.save!

when the row already exists in the database (detected by a unique-constraint violation) the values of that row are updated and saved, otherwise the new row is created.

My current solution is this:
module InsertOrUpdate def create create_or_update_impl end def update create_or_update_impl end def create_or_update_impl attrs = attributes_with_quotes(false,false) unless attrs.empty? self.id = connection.insert <<-end_sql ,"#{self.class.name} Create or update" INSERT INTO #{self.class.quoted_table_name} (#{quoted_column_names(attrs).join(', ')}) VALUES(#{attrs.values.join(', ')}) ON DUPLICATE KEY UPDATE #{update_values_partial}, id = LAST_INSERT_ID(id) end_sql end @new_record = false self.id end # returns "attr1 = 'value1', attr2 = 'value2', ..." def update_values_partial attrs = attributes_with_quotes(false,false) attrs.collect{|attr,value| "#{attr}=#{value}" }.join(",") end module ClassMethods def insert_or_update include InsertOrUpdate end end end ActiveRecord::Base.extend(InsertOrUpdate::ClassMethods)
You use it like this: class Model < ActiveRecord::Base insert_or_update # this includes the module and overwrites the default create and update methods end
Warning: You need mysql 5.1 so that LAST_INSERT_ID(id) works. (Mysql bug)

In my rails application i often have this kind of code in my erb/haml files: button_to "CommentRating.actions.create",comment_ratings_path, :rating => CommentRating::Good, :comment_id => @comment.id button_to "Comment.actions.destroy", @comment, :method => :delete
There is some repetition in it. Why not infer the i18n-key from the action? My approach: button_to CommentRating.actions.create(:rating => CommentRating::Good, :comment_id => @comment.id) button_to @comment.actions.destroy, :method => :delete # or even better button_to CommentRating.actions.create(:rating => :good, :comment => @comment) button_to @comment.actions.destroy # method is inferred from action
The parameters should also be passed to the i18n key. So for the first button_to call the translation method is invoked with: _('CommentRating.actions.create',:rating => :good, :comment => @comment)
Some of these ideas are relatively easy to implement:
Requirements:

• Each model needs an class-method called 'actions'
• Each model needs an instance-method called 'actions'
• The actions-methods return an proxy (ActionProxy) that records the method name that is invoked on it (method name = action name)
• the proxy returns an information object (ActionInformation) that contains:
  1. the instance or the class of the model
  2. the action name
  3. the parameters
• the ActionInformation has methods that infer the i18n key as well as the url

# Comment.actions.new #=> determines url, i18n key and parameters # @comment.actions.destroy #=> determines url with id of @comment # CommentRating.actions.create(:rating => :good, :comment_id => @comment.id) module ActionExtension # An instance of this class is returned when Comment.actions.new is called class ActionInformation attr_reader :instance, :klass, :action, :params def initialize(options) @instance, @klass, @params, @action = options[:instance],options[:class],options[:params], options[:action] @klass = @instance.class if @instance end def i18n_key # TODO parameter handling ["#{klass.model_name}.actions.#{action}",params.first] end def controller klass.model_name.plural end def url url = {:controller => controller, :action => action} url.merge!(:id => @instance.to_param) if @instance # TODO parameter handling: current solution: merge hash into url; better: add hidden fields url.merge!(@params.first) if @params.any? and @params.first.is_a? Hash url end end # proxy = @comment.actions #=> InstanceActionProxy(@comment) # proxy.rate(:good) #=> InstanceActionProxy(@comment).method_missing class ActionsProxy def initialize(options) raise unless options.is_a? Hash @options = options.dup end def method_missing(meth,*params) ActionInformation.new(@options.merge!(:action => meth, :params => params)) end end # called when included in ActiveRecord::Base def self.included(base) base.class_eval do # called when Model inherits from ActiveRecord::Base def self.inherited(child) #child.extend(ActionDefinition) child.class_eval do def actions ActionsProxy.new(:instance => self) end def self.actions ActionsProxy.new(:class => self) end end super end end end end ActiveRecord::Base.send(:include,ActionExtension)
Now this can be used like this: info = Comment.actions.create(:param => 1) info.i18n_key #=> ['Comment.actions.create',{:param => 1}] info.url #=> {:controller => 'comments', :action => 'create', :param => 1} info = @comment.actions.destroy info.i18n_key #=> ['Comment.actions.destroy'] info.url #=> {:controller => 'comments', :action => 'destroy', :id => @comment.to_param}
Improvements to work on:

• infer method (:delete etc)
• dont merge the parameters into the url. make them accessible seperately so they can be extracted and posted via hidden fields inside a form.
• maybe redefine actions in the models to preprocess the parameters: define_action :rate => lambda{|*params| {:rating => params[1]} }

I'm using the haml plugin in my rails application. In haml you can output plaintext like this: %div plaintext here

Since i never output plaintext in my view because i use i18n i decided to modify haml: %div my.i18n.key.here

So instead of outputting plaintext, you supply a i18n-key and haml outputs the translated text that belongs to that key.

The modification is quick & dirty and just a few lines long:
Go to the haml precompiler.rb and find the render_tag method. There should be a 'switch action' switch. Add the following lines to the switch: switch action #[...] when '', nil if not value.blank? parse = true key, params = value.scan(/\A[^,]+|[^,].*\Z/) params = ',' + params unless params.blank? value = "_('#{key}'#{params})" end end #[...] end
This assumes that '_' is the method that is used for i18n. You can even append parameters: %div my.i18n.key.here, :param1 => 'value'
This invokes _('my.i18n.key.here',:param1 => 'value')

For one project i am currently working on i had to load and parse some binary files with ruby. The parser code was not very nice, so i came up with an idea: d = DataFormat.description do int :the_id float :value end # binary data in the stream: int(1337)float(-0.1337) data = d.read_from(stream) data.the_id #=> 1337 data.value #=> -0.1337 The cool thing about this is: The DataFormat is a description of the data format and the code to load and save a file in this data format is generated automatically. So you dont have to worry about the loading and saving code, you just have to specify the format. Some more examples: This one reads an array of values. d = DataFormat.description do uint :arr_length array(:things,:length => :arr_length) do int :thing_id float :value end end # stream: int(2)int(4363)float(0.5)int(66584)float(-1677.5) data = d.read_from(stream) data.arr_length #=> 2 data.things[0].thing_id #=> 4363 data.things[0].value #=> 0.5 data.things[1].thing_id #=> 66584 data.things[1].value #=> -1677.5 The data that is returned is an instance of the class AttributeHash. The AttributeHash just wraps an hash and overwrites method_missing to delegate all attribute accesses to the wrapped hash (so it behaves like a javascript object). But you can specify that an instance of some custom class should be created instead of an AttributeHash. Example: class ItemList attr_accessor :name, :max_size, :items end class Item attr_accessor :value end d = DataFormat.description do string :name uint :max_size array(:items,:class => Item) do string :value end end data = d.read_from(stream,:object => ItemList.new) data.class #=> ItemList data.items[0].class #=> Item data.items[0].value #=> "yes" data.items[1].class #=> Item data.items[1].value #=> "no" The requirement for the class that will be instantiated is just that is must have methods for "attrname=" calls with "attrname" specified in the data format.
The different types that are currently available to describe a data format:

Supported types
NumberSerializer: short, int, long (+unsigned: ushort etc.), float, double

uint :attribute_name, :min => 1145, :max => 67546 

StringSerializer: nullterminated(default) or fixed-length

string :attr_name, :length => 32

MagicSerializer: throws exception when the magic value (in this case 1337) is not found at the pecific position

magic :magic_number, :value => 1337

ArraySerializer: reads an array from the file. The data format of each entry can be specified.

array(:things,:length => :arr_length) do
	int :thing_id
	float :value
end

Status
Experimental version.
Todo:

• Option to specify if format is big- or little-endian
• Store errors (eg: integer out of range) in an error hash like in active record
• Optional elements (if :someattr == 0, then :otherattr is not present)
• Skip sections (if :someattr == 0, then skip x bytes)

Test syntax highlighting:
class Hash # h = {:a => 1, :b => 2} # h.extract_hash!(:a).should == {:a => 1} # h.should == {:b => 2} def extract_hash!(*keys) keys = keys.first if keys.first.kind_of? Array extracted = collect{|key,value| keys.member? key} self.reject!{|key,value| keys.member? key } extracted end end See: Max Horvath - Syntax Highlighting for your Movable Type blog

Blog created.