Friendly advice beforehand; Using http://filepicker.io/ may be a way better idea if you are hosting in Heroku, just make sure if fits your constraints before get hard work done.

Solution Spec

Hard limit file size of the request, so the process don’t block for too long, and don’t blow memory!

If you behind a server such as Apache or Nginx, you can impose a limit to the request size, and you should!

Unless you are in Heroku, and afaik, there is no way to do that, at least just yet. So yes, this can be a major security breach for Rails apps on Heroku.

Given a successful upload, pre-validate size.

The ‘official’ solution attempt to validate the size after the file have been processed. It doesn’t help, since when processing an image rather large (6Mb image consumed 2GB memory in my case) your process will be killed! Letting your website down for some time, and letting your users down as well.

For gifs, take only the first image (less memory consumption too)

When processing .gifs it seems to make a vertical frameset will all the images in the sequence, so it looks like a movie roll, which is not what most people want. Lets just extract the first frame.

Interestingly enough, I found that the processor is invoked for all frames in the .gif. (thanks debugger!)

Solution code

This code takes care the mentioned specs (except for the request size limit), and I think the great advantage is that it avoids opening a file as Image if it fails the size constraint. As well as being very efficient with gifs (only acting on the first frame).
It works on Heroku, with integration for S3, and should work on Amazon Cloud and other VPS.

The shortcome is about handling the exception which is a bit messy involving controller-side logic in a non-automated AR fashion.

Controller

  def create
    begin
    @post = Post.new(params[:post])
    rescue Exception => e
      if e.message == 'too large'
        redirect_to news_path(err: 'file')
      else
        raise e
      end
    end
   #...

uploader

# encoding: utf-8


class NewsUploader < CarrierWave::Uploader::Base

  include CarrierWave::RMagick

  include Sprockets::Helpers::RailsHelper
  include Sprockets::Helpers::IsolatedHelper


  def store_dir
    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
  end

  def pre_limit file
    #require 'debugger'; debugger
    if file && file.size > 5.megabytes
      raise Exception.new("too large")
    end
    true
  end

  def only_first_frame
    manipulate! do |img|

      if img.mime_type.match /gif/
        if img.scene == 0
          img = img.cur_image #Magick::ImageList.new( img.base_filename )[0]
        else
          img = nil # avoid concat all frames
        end
      end
      img
    end
  end

  version :large, if: :pre_limit do
    process  nly_first_frame
    process :convert => 'jpg'
    process :resize_to_limit => [1280, 1024]
  end

  # Create different versions of your uploaded files:
  version :small, if: :pre_limit do
    process  nly_first_frame
    process :convert => 'jpg'
    process :resize_to_limit => [360, 360]
  end


  # For images you might use something like this:
  def extension_white_list
    %w(jpg jpeg gif png)
  end

end

It meant so much to me!

For around 4 months I’ve been using Node.js, and before that, for 3 years, programming Rails.

As soon as I started on Node.js, I could feel that something was different. My little Computer Science bachelor conscience was starting to tell me: now you are starting to do it right

But then, lets go back, Ruby’s syntax is lovely.. Rails API is sugar! But still, it’s neverland. Why??

It does not fit real world! It is a thin layer of happiness, so delicate, that we feel fear of touching it and breaking it. So what we puny humans do? We delegate it to those genius heroes who will be able to take that code and maybe squeeze a few more couples of requests/sec!

But not even that is the cancer I mean.

The cancer here is represented by clown hosting the video. “Oh those scientific articles mess with our head and stuff O.o Let me chew that evil reality and I will give you the RIGHT (sugar coated) solution!” and all other non fun nor assertive statements. By the way, he may be referring to the C10K problem, and alike, articles.

The problem here is, VP  EngineYard and want ppl addicted on his junk. He does not host Node.js.

Ruby always had so many language implementations to solve some important language problems, as well as servers. This is not the first time a good solution for ruby is born (JRuby+Trinidad), but why would they share it before if he could have people paying for so much RAM?

The reason I believe he felt compelled to share it now, is that Node.js unoptimized code can outperform Rails by a LOT,  under 150Mb.

But my main problem is fear of complexity. The host talks about it all over the initial part of the video. He refers his audience under constant fear of it’s own ignorance all the time. This is a awful, and that’s how I felt using Rails. Such a large stack, complex language design, only understanding the framework code itself was hard task.

To keep people in bliss ignorance he just goes like: “Oh I promissed evented? We are past that, right?! HAAAA” so just be happy and keep the status quo. You would’t want to mess your pretty little head with asynchronous code, would you?

I like Node.js, besides performance, language is simple; it is JavaScript, open Objects, closure and more. Of course, don’t assume well-written JS is something easy to do. No great code in any modern language is easy to achieve.

If you’ve developed Rails, you have concepts of MRI, thin, mongrel, jruby, 1.8.7, 1.9.2, rubinius, unicorn, and LOT MORE, whilst in node.js world all that stands for: node.js. It is a unification point for language and server.

What about gems?  npm, a easier system of distributing packages.

Wrapping it up, node.js is no silver bullet, it just made me realize the problems I had while programming ruby, as much as ruby did it for me on php. If nothing else, node.js helped improve ruby’s community by adding options to the web development mainstream.

Would I work with Rails again? If a employer would point me that out as the only chosen solution, then yes, and I’d probably try that stack, but I prefer confidence instead of fear.

Hello!

I am trying to do a sort of indirect comparison between Rails and Node.js. The very main reason of being indirect, is that Rails is a Framework, while Node.js is an implementation of a programming language with custom libraries.

If it were be to put in a simple phrase, Rails is resourceful and Node.js is light and fast.

Lets elaborate some..

Rails

Is the most complete open-source framework available (that I know of)! Big companies use it. It can do lots of stuff well, in an organized manner; this meaning, Rails is more than just MVC, it has a full stack of features well-integrated, at the same time being very modular. Some of the features included out of the box:

• Database adapter for the majority of them, supporting plug your own.
• Database migrations, so multiple dev can sync and experiment with their DB.
• Powerful engines for Views, Controllers and Models.
• Support to code generator.
• Has structure to all sorts of tests and friendly to TDD.
• Really awesome documentation.
• Model has all kinds of hooks, validations and associations.
• Controller has support to handle XML/JSON in the same action that serves HTML.
• Gems that integrate, for instance, Memcached, MongoDB, Auth and lots more.

Node.js

Two things make this platform suitable for web:

Its engine, V8 is very fast! In a very loose average, 8 times faster than Python (or even up to 200 at peak). Python already outperforms Ruby (ref. bottom)

Second point; and this argument is separated from the above, is that it async-driven (is built around reactor pattern). As in the case, requests can be performed in parallel, without any blocking I/O. A single server can handle a lot. (update) And with >0.6.0 Cluster API, it can scale to use all of available CPU cores.

So, it is a very new sort of backend language, but huge players, besides Joyent, who invented it, are adopting it, including LearnBoost and LinkedIn, which has an awesome article about using. The language, and it’s main web framework, Express, deserve a list of features (you can check more info in the references below).

• It´s web server is able to handle a HUGE number of connections out of the box
• Various libraries can be run on browser, the same as in the server
• Very friendly to Websockets (real-time web apps)
• Lots of libraries are being ported to it from other langs.
• Express, inspired in ruby´s Sinatra; is very light on memory but also very powerful

Summarizing, When to use each?

Rails really shines when..

• The database is complex in terms of associations.
• The app structure is well defined.
• Business rules are complex, and validation is needed.
• When the number of requests isn´t the a decisive factor.
• Administrative interfaces.
• Many developers in parallel keep the DB up-to-date with migrations
• The database to be used is undefined, or may vary.

This being said, there is no reason at all, a web-site or service can´t easily integrate both.

– I’d appreciate if you could leave a comment, either to talk about your case, or add up.

References

UPDATE: http://www.mikealrogers.com/posts/a-new-direction-for-web-applications-.html

http://guides.rubyonrails.org/

http://railscasts.com/

http://blog.heroku.com/archives/2011/6/22/the_new_heroku_2_node_js_new_http_routing_capabilities/

http://nodejs.org/

http://akitaonrails.com/2011/04/16/twitter-muda-de-ruby-para-java-ruby-e-3x-mais-lento-que-java

http://venturebeat.com/2011/08/16/linkedin-node/

http://blog.bossylobster.com/2011/08/lesson-v8-can-teach-python-and-other.html

https://github.com/LearnBoost

http://www.readwriteweb.com/hack/2011/01/how-3-companies-are-using-node.php

http://twitter.com/#!/FlockonUS/status/104655096956190720

https://github.com/LearnBoost/cluster

Introduction (goal)

I’ve been projecting for sometime my tag based search engine for sometime now. And while it is something relatively simple, query performance still have a great impact on that matter.

It should be a project, with roots in gamification; and I choose Ruby on Rails, and not GAE’s Python or Java framework due I do not want to be stuck in a hosting platform for whatsoever reason.

AppEngine, what’s great?

AppEngine has many, cool things. Those including some that should make my life a lot simpler

• Generous elastic free quota for all stuff I needed
• BigTable, with stable performance (it is suppost to perform so well with thousand entry through a million )[demo]
• They have the type List in DataStore, witch is exactly what I need to make a good queries
• Should scale seamless, no pain
• Have a great panel, that allows easy data manipulation, and great reports.

AppEngine, what is bad, for Rails?

After building my hello world on GAE, things looked awesome; a proof of concept right there! Rails 2.3.8 running smooth.

But then it began.. migration, data backup, gems like omniauth, sorta elaborated queries.. where to look for all those stuff? Rubygems system is disabled, and no doc is easily found, if any doc is around. So I got to go build conceptual proofs  for all those things?

So it happens, that their landing page for Rails, is stale for years; a big turn down! And still it hard to find some decent support for Rails (@woodie does help in docs, but can’t be accepted as the only source)

Recently they’ve announced a they are going beta with the Go language;  what sounds really great, still in practice it mean Ruby won’t be getting support (if ever) in a very long while.

So, Heroku and why

For being a Computer Scientist . I am a big fan of Google capacity of execution and performance for years, but the downsides have been just too great too keep on. So let’s check Heroku.

• I had prior experience there
• Heroku offers Rails out of the box, working with Omniauth.
• They also have a free quota to try (1 dyno ~ 10-50req/sec)
• 240MB from MongoLab
• Nice features
• Robust and elastic scalable (dyno charge per hour)

Final Considerations

The pro in this scenario, is that they take Rails with all gems I could need, no harass there, things just work! And if I grow tired of then, I can just switch host

Why not a VPS? I’ve had Linode for sometime now, they have some great management panel; but the concern about the O.S. security and app scalability is considerable.. Sure is cool to config all my features from the ground; but considering business, this kind of setup must be taken professionally.

Google AppEngine, or GAE, is a great platform, for their supported languages. If I were to host there, I would definitely learn Go, for all great features intended, and the attention Google is giving it.

Well, for a system with around 20 users that should be no problem at all in the begin, right? – Right but also Wrong!

I’ve tested using the system on the same settings, but for some reason, after a while the reading on the Database by Rails became very inconsistent. While in console I would find some recently created objects by Rufus Scheduler, the web app would not see then until the server was restarted! Weird results, but a price to pay for not listening the common sense =)

The solution would be to migrate the schema and data to some easy to use Mysql. Schema as widely known is extremely easy to migrate on Rails framework (if used properly).

Searching for solutions for migrating data from different databases may be a pain, but given a great Rails tool it is rather simple! Introducing the gem yaml_db, made by the Heroku people.

As the commands are simple as :dump and :load, I don’t see why go longer in the explanation.

The whole process took less than 2 hours, including a small bug fix in a non-agnostic code =)

At service of BananaBrains, FIRE the social soccer game RPG.

Isso quer dizer que vou me focar em retransmitir bons argumentos de referências que respeito.

Argumentos Porque muitas Startups Usam Rails?

Mas e a Performance? Twitter muda de Ruby para Java. Ruby é 3x mais lento que Java.

Corroborando, o que realmente importa, o processo You Are Solving The Wrong Problem

Venho desenvolvendo Ruby, mas não exclusivamente isso à mais de 2 anos, tenho muito o que aprender ainda. As ferramentas de Console são extremamente úteis, aconselho abusar delas, seja como 1ª linguagem ou migrando de outras como Java, C++.

Sigam pessoas legais no Twitter para se manter informados

Como a documentação da gem está muito bem feita nem vou me preocupar em explicar isso, mas vou dar uma sugestão de uso.

Temos essa necessidade grande junto à um cliente de importar uma quantidade massiva de dados, então ele me sugeriu importar de uma planilha, o resultado foi esse modelo:

Como o meu objetivo aqui foi bastante específico, vou só passar uma idéia geral do modelo:

• As celulas azuis são usadas pelo usuário para inserir dados
• As celulas cinza são de uso exclusivo do sistema para feedback

O sistema está muito crú ainda, mas pode ser uma boa fazer uma Gem com isso. Vou deixar em anexo o Model e o Controller que usei para fazer a importação de dados ‘bulky’.

Model GIST

Controller GIST

A idéia no código é que cada linha pode ser julgada por 3 resultados distintos:

• CADASTRADA: é considerada já persistida e ignorada futuramente
• INVÁLIDA: Por já ser cadastrada, dada uma condição de busca
• IGNORADA: No caso de linha vazia (invisível)

O que eu considero de mais legal nesse sistema é a capacidade de interação bi-lateral: O usuário fornece uma quantidade massiva de dados e o sistema responde com possíveis problemas.

Sugestão: Retornar na coluna de erros: registro.errors é bastante interessante pra casos onde uma validação elaborada ocorre, e o usuário tem capacidade de entender uma mensagem um tanto “confusa”

Abraços!

It is only a shame they only support Python and Java and there is no native support for Ruby.
As there are these programmers that just can’t take NO for an answer, luckily, there is this post from Woodie, he uses JRuby for getting the job done, along with a gem called rails_appengine.
Just be sure to read some of my comments by the bottom about some patches if things go wrong with you (I’m using Ubuntu 10).

The first surprise you get as you start your app, and start playing with this framework mod, is that is a MVC for sure, but there is no ActiveRecord (or migrations).. how come?!
It happens to be that AppEngine does not support MySQL or any of the regular DBs, instead it uses its own proprietary solution, DataStore. In order to access it, the solution provided is TinyDS, that you can learn a lot more on this github file by Takeru; although it is a Sinatra app, the code to query is the exact same.
After understanding some of that I got surprised by the declaration of a type called :list, that looks very much like an Array, I wonder if there are different methods to update and query it..

App Engine also has services for storing large files, images, caching, tasks, e-mail, among other handy services! Besides, the free-quotas are large.
Unfortunately, as this version is, there is no directly bind (or if so, there is no documentation about) for all those services provided.
On that same example from Takeru however, one can observe it requires ‘appengine-apis/memcache’, and uses it on the app. I tried myself and found success using it, what leads me to believe that the services may be accessed likewise.

For the moment I’m pretty happy with today’s progress, it was extremely easy to deploy, my app. Just be sure to setup the WEB-INF/app.yaml with the proper app-id.

For those who have interest the account is free and enabled for any Google Account, make your here. I will just leave the warning, for the time being that this thing seems pretty ‘green’, I just would be very careful planing to develop any complex App to host over this Ruby implementation because it looks like I could hit a dev wall at anytime.

The problem: I need to log my user’s actions on the site ( a game) so I can Datamine it later, It is also very desirable to investigate each user individually.

My solution: (still primitive) A ruby lib that is able to accumulate some actions (in a array) and then append it to a log  File. Aafter_filter @ application_controller that auto-logs every action taken. The action can set a custom warn level, and a custom message.

I made a GIST with this. link1 link2

Usage: The usage is actually automatic, but you can custom with 2 options on a Action, Example:

def create
    @user_session = UserSession.new(params[:user_session])
    
    @bf_errors = 10
    @bf_minutes = 10
    #logger.info ">>>> #{@bfw.to_s}, #{session['create_number']}"
    
    if @bfw = brute_force_warning
      captcha = verify_recaptcha(:model => @user_session, :message => "Favor digite as letras que aparecem distorcidas")
      if (@bfw == :active && !captcha)
        @warn = 8
        @action_obs = "#{@bf_errors} per #{ @bf_minutes} minutes. Email:#{@user_session.try( :email)}, pass: #{@user_session.try( :password)}. "
        render :action => "login"
        return true
      end
    end

Discussion: I chose JSON for being very extremely easy to parse on JavaScript, which has great Libs for data visualization.
I considered the rails Buffered Logger, Beanstalk and direct File Write, but I believe the method I’m using is way faster than those. My assumption is because all I do is native to Ruby, with minimal memory use, and disc access.

TODO:
. A plugin that handles this.
. A controller-action-view to visualize this Data =)

• I had ruby 1.8.7 and Installed RVM as ROOT, not the gem
• I did the above without knowing about the working of RVM
• I had ruby 1.8 and 1.9 installed, and the gem had a confused env
• Lots of other confusing paths and installs
  

Now, the good part.. Simple rails 3.0 install

How I did it work*:

• Removed RVM by the great command sudo rvm implode
• Also ruby1.9, sudo aptitude remove ruby1.9
• Updated my gems:

sudo gem install rubygems-update
gem env | grep 'EXECUTABLE DIRECTORY'
sudo `gem env | grep 'EXECUTABLE DIRECTORY' | ruby -e "puts  gets.split(': ', 2).last"`/update_rubygems

• Installed Rails 3.0.0, sudo gem install rails -v3.0.0
• Made a project on rails, rails new dum; cd dum
  
• Installed mysql gem, bundle install
• rails server

Great Refs:
http://blog.costan.us/2010/04/rails-3-development-setup-for-ubuntu.html
http://stackoverflow.com/questions/3558656/how-to-remove-rvm-ruby-version-manager-from-my-system
http://stackoverflow.com/questions/3722701/getting-crazy-over-rails-3-rvm-gems
http://rubyonrails.org/screencasts/rails3/active-relation-active-model

*: I have not tried it for real, with several gems, I will update if anything fails It is all working just fine

Today I found a resuld I did never expected, it goes like this…

Intro: I thought: in a hash there must have a hash function that is somehow costly  to map a key to a value, right? And while learning C in my grad, I were taught that SWITCH CASE was a very fast and optimized structure.

So.. If i get the ruby’s equivalent CASE WHEN to map a key to a value dynamically that should be really fast! Dead Wrong!

I benchmarked 3 ways: A fixed CASE WHEN, a evalued CASE WHEN, and the friendly HASH, and got these results:

@ ruby 1.8.7 (2009-06-12 patchlevel 174) [i486-linux]

      user     system      total        real
CASE WHEN         1.370000   0.130000   1.500000 (  1.507988)
EVAL CASE WHEN  15.110000   0.440000  15.550000 ( 15.548754)
HASH[:sym]       1.000000   0.140000   1.140000 (  1.147406)

@ ruby 1.9.1p243 (2009-07-16 revision 24175) [i486-linux]

      user     system      total        real
CASE WHEN         0.710000   0.000000   0.710000 (  0.707460)
EVAL CASE WHEN  34.460000   0.010000  34.470000 ( 34.460126)
HASH[:sym]       0.410000   0.000000   0.410000 (  0.416476)

The source is here:

require	'benchmark'

Benchmark.bm do|b|
 vdd = {:a =>	'amor',
 :b	=> 'valor',
 :c	=> 'honestidade',
 :d	=> 'tabela',
 :e	=> 'sinceriadade'
 }

 b.report('CASE WHEN       ') do
	1_100_000.times {
		valor_unico = [:a,:b,:c,:d,:e][rand(4)]
		case valor_unico;	when :a then	'amor';	when :b then	'valor';	when :c then	'honestidade';	when :d then	'tabela';	when :e then	'sinceriadade';	else	false; end;
	}
end

 b.report("EVAL CASE WHEN ") do
	$tree = 'case valor_unico;	'
	vdd.each	{	|k,v|	$tree	<< "when :#{k} then	'#{v}';	"	}
	$tree <<	'else	false; end;'
	def case_when(v)
		valor_unico	=	v
		eval $tree
	end

	1_100_000.times { case_when(	[:a,:b,:c,:d,:e][rand(4)]	)	}
 end

 b.report("HASH[:sym]     ") do
	1_100_000.times { vdd[	 [:a,:b,:c,:d,:e][rand(4)]	]	}
end
end

And the Conclusion is: Using a Hash can be pretty fast, since it must be really optimized structure in Ruby!
The CASE WHEN felt slow compared to the hash, as weird as may be .
Hashes still have the advantage of very simple reading, writing and updating for the programmer, they also append values easily.

Improving: A potencial future test would be to make a hash that is way bigger than this, the results could change a little.
Other idea is mapping the key for something other than a Symbol, like a String or a custom Object.

Me and my friend @pirelenito(+blog) we’re coding yesterday, he wanted to learn Rails, and I get something new, the result was this marvelous creation: the CanTweet

The highlights inner work of the code is basically how we get the info from Twitter ruby API and convert the twits length into the new Canvas tag element from HTML5,

Here is a small snip from our lib PV created:

require "twitter"

class TwitRetriever
  COUNT = 50
# ...
def sizes
    twits = []
   Twitter::Search.new.containing(@keyword).per_page(COUNT).fetch.results.each do |r|
      twits.push r.text.size
    end
    twits
  end
end

And finally we draw in the canvas using the functions:

var graph = document.getElementById("graph")
var context = graph.getContext("2d")
context.strokeRect()
context.strokeStyle = "rgb(r,g,b)"
context.beginPath()
context.lineTo(x, y)
context.stroke()

Resources:
CANVAS
- https://developer.mozilla.org/en/HTML/Canvas
- https://developer.mozilla.org/en/Canvas_tutorial
- http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#2dcontext

TWITTER API
- http://twitter.rubyforge.org/
- http://github.com/jnunemaker/twitter
- http://rdoc.info/projects/jnunemaker/twitter

Interpolator implements ways for you to do linear, cubic, lagrange and spline interpolation easyly.

Check this short example:

# a curve that rise and fall fast
t = Interpolator::Table.new 0.1 => 2, 0.4 => 3, 0.8 => 10, 1.0 => 12, 1.2 => 11, 1.4 => 8
# LINEAR
 t.style = 1
 [0, 0.5, 1.0, 1.5, 2.0].each {|x| puts( t.interpolate(x)) }	
1.66666666666667
4.75
12.0
6.5
-1.0

# LAGRANGE
 t.style = 2
 [0, 0.5, 1.0, 1.5, 2.0].each {|x| puts( t.interpolate(x)) }
2.47619047619048
5.125
12.0
5.75
-13.0

# LAGRANGE 3
 t.style = 3
 [0, 0.5, 1.0, 1.5, 2.0].each {|x| puts( t.interpolate(x)) }
3.64021164021164
4.57936507936508
12.0
6.0625
-3.00000000000003

# CUBIC
 t.style = 4
 [0, 0.5, 1.0, 1.5, 2.0].each {|x| puts( t.interpolate(x)) }
1.99712997129971
4.39777444649446
12.0
6.36704335793358
7.50922509225093

# SPLINE
 t.style = 5
 [0, 0.5, 1.0, 1.5, 2.0].each {|x| puts( t.interpolate(x)) }
1.30687830687831
4.45535714285714
12.0
6.875
35.0000000000001

There you go, a simple use of the Interpolator, very nice lib..
For tests about performance I don’t have any result or benchmark, but sure would be cool post

Get the gem

Interpolação linear com biblioteca em ruby, fácil!

Como invocar um método de instância de mesmo nome no pai

De dentro do método filho ??

- A resposta é super e fácil   +Tópico completo

Começando aqui com o tema mais batido que pode haver no blog de qq programador que usa ruby, i.e., Começando a Usar Ruby!

Já lí vários desses posts e posso afirmar, nenhum deles me levou, ou levou qq um que conheço, a programar ruby, pois só a necessidade pode levar alguem se self.motivar! mas esse aqui é realmente bom porque cobre o mais essencial, ou seja:

Ruby não é sinonimo de Rails nem de WebDev !!!!

>> Leia o post de PotHix

- Ruby é açucar sintático

Será que MeuPonto serve para você???

- Se você trabalha em um sistema de Banco de Horas, gosta de ruby e linha de comando (bash), então SIM!

Sua boca já esta salivando, e seu cérebro grita: COMO USAR ??

- Puta merda é simples! Depois de instalado (o que só requer 1 passo), você pode usar comandos do tipo:

meuponto in #=> Você acabou de registrar entrada!

meuponto out #=> Você acabou de registrar saída!

meuponto hoje #=> Exibe relatório diário

Logo teremos outras opções como relatório por data, semana e mês um interface HTML

Baixa já o seu! é gratis!  >> MeuPonto

- Rising from the dead blog’s graveyard

Trabalho novo, rotina nova! Pois bem, comecei a trabalhar @Guenka uma empresa de software moderna. Mas pq moderna? Eles tem departamento de desenvolvimento com Rails, pesquisa e outro de inovação em web! Nice humn?!

Andei trabalhando num projetinho que surgiu do meu esquema de trabalho com banco de horas, e como estive aprendendo Git, resolvi conciliar as coisas e criei uma espécie de máquina de ponto pessoal em Ruby no GitHub.

Mais a respeito no próximo post!

• Object Oriented JS
• Prototype Lib
• XML.ObjTree (JSAN) Lib
• TDD ( i believe )
• Aptana Studio

Some Snippets:

To get the XML into HTML I built a really small ruby script that convert the file into a JS var and considering using the same script on the website to remove some of the ‘garbage’ out of the XML and print it on the page.

Select UML for the sheet pallet. Only a reduced set of the tools will be interpretated, the X´s will be ignored.

These is the selection of tools available:

dia -> ruby statemachine

Ok! A quick note about the arrows, is that the 3 of those can be used under any TRANSITION circunstances (since all connect state with state), but you will see if you try, some arrows fit better in the indicated manner.

simple ex

• So that is a very basic example, it is valid, notice that you need to indicate a BEGINNING connected with a STATE since the XML has no defined order among the elements.
• Not all TRANS are required to declare an action,  the EVENT alone is ok, but if your going to declare both  use  / to separate <  event_name / run_action >
• On STATES you may use the fields: Entry action and Exit action they will trigger respectively on_enter, on_exit

Soon part 2

After a loooong while I decided to dev something just so I don´t get too rusty!

The concept is: Statemachine is a fine implementation of FSM for ruby (act_as_state_machine is also an option). The author  wrote a nice guide for layperson (or forgetful like me ) BUT still something is missing! In all examples there are diagrams, those are very necessary for us to understand what to implement in the machine, but a huge one´s mat get really confusing. The solution would be to convert the Diagram into Ruby code!

The plan: Dia is a great and easy to use diagramming tool, win and linux able, it´s save file is in XML.What i´m gonna do is make a JS that is able to parse it´s code and generate ruby =)

Execution:

1. Make a definition of the simbols accepted by the conversion. Document it (blog).
2. Understand the .dia XML, what is gonna be used inside?
3. Make a website that receives a file .dia
4. Make a response page with the contents
5. In this page, JS will read, convert (the XML inside .dia) and return a ruby code for the statemachine in a textarea.
6. In future (since the future is unknown this may never happen..) there will be no upload to the server, a Flash reads the content and return to JS.

Purpose: I love ruby lang, every Computer Science student must at least once use a Finite State Machine, maybe this interface will make things more attractive so he have a taste of ruby programming..

Long automata’s description may be very boring and error prone this should make the assembly easier.

The credit of the original code is @HelgeG guy

This was only enhanced to make a warning first and count the kills, still under testing.

require 'find'
require 'fileutils'

puts "\n\t\t\t! WARNING !\n\nYou are about to remove .SVN from this folder and all sub-folders"
puts "# This program is to be used on a backup folder, no way back! \nCONTINUE?"
resp = gets

if resp.include?('s') || resp.include?('y')
	i = 0
	Find.find('./') do |path|
	  if File.basename(path) == '.svn'
		FileUtils.remove_dir(path, true)
		i += 1
		Find.prune
	  end
	end
	puts "#{i} .svn folders were deleted along with their juice.."
	sleep 3
end
puts "Bye"
sleep 1

Use on your own Risk!