restfulie 1.0.0 → 1.0.3

data/.gitignore

@@ -0,0 +1,20 @@
+coverage
+Gemfile.lock
+test.sqlite3
+doc
+*.gem
+pkg
+.tmtags
+tmtags
+*~
+*.swp
+*.swo
+.rvmrc
+*.sqlite3
+log
+*.log
+.DS_Store
+.yardoc
+server.pid
+.bundle
+site/config/environment.rb

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "full-examples/restfulie-restbuy"]
+	path = full-examples/restfulie-restbuy
+	url = git://github.com/caelum/restfulie-restbuy.git

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Rakefile

@@ -6,36 +6,13 @@ require 'rake/rdoctask'
 require 'rspec'
 require 'rspec/core'
 require 'rspec/core/rake_task'
-require File.expand_path('lib/restfulie')
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require File.join(File.dirname(__FILE__), 'lib', 'restfulie', 'version')
 
 GEM = "restfulie"
 GEM_VERSION = Restfulie::VERSION
-SUMMARY  = "Hypermedia aware resource based library in ruby (client side) and ruby on rails (server side)."
-AUTHOR   = "Guilherme Silveira, Caue Guerra, Luis Cipriani, Everton Ribeiro, George Guimaraes, Paulo Ahagon, and many more!"
-EMAIL    = "guilherme.silveira@caelum.com.br"
-HOMEPAGE = "http://restfulie.caelumobjects.com"
-
-spec = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.summary = SUMMARY
-  s.require_paths = ['lib']
-  s.files = FileList['lib/**/*.rb', '[A-Z]*', 'lib/**/*.rng'].to_a
-  
-  s.add_dependency("nokogiri", [">= 1.4.2"])
-  s.add_dependency("json_pure", [">= 1.2.4"])
-  s.add_dependency("rack-conneg")
-  s.add_dependency("sqlite3-ruby")
-  s.add_dependency('tokamak', "~> 1.1.2")
-  s.add_dependency('medie', "~> 1.0.0")
-  s.add_dependency('respondie', "~> 0.9.0")
-  
-
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-end
 
 module FakeServer
   def self.wait_server(port=3000)
@@ -72,6 +49,7 @@ module FakeServer
   
   def self.start_server_and_run_spec(target_dir)
     success = Dir.chdir(File.join(File.dirname(__FILE__), target_dir)) do
+      system('bundle install')
       system('rake db:drop db:create db:migrate')
       self.run "rails server", "rake spec"
     end
@@ -112,12 +90,7 @@ namespace :test do
 end
 
 RSpec::Core::RakeTask.new(:spec) do |t|
-  # t.spec_files = FileList['spec_*.rb']
-  t.spec_opts = ['--colour', '--format progress']
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
+  t.rspec_opts = ['--colour', '--format progress']
 end
 
 Rake::RDocTask.new("rdoc") do |rdoc|
@@ -131,11 +104,6 @@ optionally do
   end
 end
 
-desc "Install the gem locally"
-task :install => [:package] do
-  sh %{gem install pkg/#{GEM}-#{GEM_VERSION} -l}
-end
-
 desc "Create a gemspec file"
 task :make_spec do
   File.open("#{GEM}.gemspec", "w") do |file|
@@ -143,9 +111,9 @@ task :make_spec do
   end
 end
 
-desc "Builds the project"
-task :build => ["install", "test:spec"]
+desc "Runs everything"
+task :all => ["install", "test:spec"]
 
 desc "Default build will run specs"
-task :default => :build
+task :default => :all
 

data/full-examples/.gitignore

@@ -0,0 +1,4 @@
+log
+pkg
+db/*.sqlite3
+.DS_Store

data/full-examples/README.textile

@@ -0,0 +1 @@
+Restfulie full client and server examples.

data/full-examples/mikemaze/README.textile

@@ -0,0 +1,6 @@
+This software tries to solve Mike Amundsen's maze problem by using the Restfulie
+Ruby client.
+
+To run it use:
+
+ruby maze_basic.rb

data/full-examples/mikemaze/maze_basic.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'restfulie'
+
+Restfulie::Common::Logger.logger.level = Logger::INFO
+
+current = Restfulie.at('http://amundsen.com/examples/mazes/2d/five-by-five/').accepts("application/xml").get.headers
+
+steps = 0
+
+visited = {}
+path = []
+
+while(!current.link("exit"))  do
+  
+  puts "available links are #{current.links.keys}"
+  puts current.links
+  
+  link = ["start", "east", "west", "south", "north"].find do |direction|    # puts "#{direction} #{!visited[current.link(direction).href]}"
+    current.link(direction) && !visited[current.link(direction).href]
+  end
+  
+  if !link
+    path.pop
+    link = path.pop
+  else
+    link = current.link(link)
+  end
+
+  visited[link.href] = true
+  path << link
+  current = link.follow.get.headers
+  
+  steps = steps + 1
+  
+end
+
+puts "solved in #{steps} steps"

data/full-examples/mikemaze/maze_solver_spec.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require 'restfulie'
+
+class Maze::Enter
+  def execute(maze)
+    maze.item.start.get
+  end
+end
+
+class Maze::Move
+  def initialize(direction)
+    @direction = direction
+  end
+  def execute(room)
+    room.cell.send(@direction).get
+  end
+end
+
+class Maze::Pick
+  def execute(mazes)
+    mazes.maze.get
+  end
+end
+
+class Maze::Back
+  def initialize(path)
+    @path = path
+  end
+  def execute(actual)
+    return nil if @path.empty?
+    last = @path.delete_at(@path.length-1)
+    Restfulie.at(last).get
+  end
+end
+
+class Maze::BackTracObjective
+  
+  def initialize
+    @path = []
+    @visited = []
+  end
+
+  def next_step(resource)
+    next_step2(resource) || Maze::Back.new(@path)
+  end
+  
+  def visited?(uri)
+    @visited.include?(uri)
+  end
+
+end
+
+class Maze::ExitBackTracking < Maze::BackTracObjective
+  
+  def completed?(resource)
+    resource.respond_to?(:cell) && resource.cell.links(:exit)
+  end
+  
+  def next_step2(resource)
+    direction = [:east, :west, :north, :south].find do |direction|
+      resource.respond_to?(:cell) && resource.cell.links(direction) && !visited?(resource.cell.links(direction).href)
+    end
+    if direction
+      @path << resource.cell.links(direction).href
+      @visited << resource.cell.links(direction).href
+      Maze::Move.new(direction) 
+    elsif resource.respond_to?(:item) && resource.item.links(:start)
+      Maze::Enter.new
+    elsif resource.respond_to?(:maze)
+      Maze::Pick.new 
+    else
+      nil
+    end
+  end
+  
+end
+
+# def scenarios
+#   
+#   When can go east
+#   Then take east
+#   
+#   When can go north
+#   Then take north
+#   
+#   When can go west
+#   Then take west
+#   
+#   When can go south
+#   Then take south
+#   
+#   # what about some random stuff?
+#   
+#   When there is a maze
+#   Then enter it
+#   
+#   When there are mazes
+#   Then pick a random one
+# 
+# end
+
+
+
+
+
+describe Maze do
+  Mikyung.new(Maze::ExitBackTracking.new, Restfulie.at('http://amundsen.com/examples/mazes/2d/five-by-five/').accepts('application/vnd.amundsen.maze+xml').get! ).run
+end

data/full-examples/rest_from_scratch/part_1/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/**/*

data/full-examples/rest_from_scratch/part_1/.rspec

@@ -0,0 +1 @@
+--colour

data/full-examples/rest_from_scratch/part_1/Gemfile

@@ -0,0 +1,33 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.0.0'
+
+# Bundle edge Rails instead:
+# gem 'rails', :git => 'git://github.com/rails/rails.git'
+
+gem 'sqlite3-ruby', :require => 'sqlite3'
+
+gem 'restfulie'
+
+# Use unicorn as the web server
+# gem 'unicorn'
+
+# Deploy with Capistrano
+# gem 'capistrano'
+
+# To use debugger
+# gem 'ruby-debug'
+
+# Bundle the extra gems:
+# gem 'bj'
+# gem 'nokogiri'
+# gem 'sqlite3-ruby', :require => 'sqlite3'
+# gem 'aws-s3', :require => 'aws/s3'
+
+# Bundle gems for the local environment. Make sure to
+# put test-only gems in this group so their generators
+# and rake tasks are available in development mode:
+group :development, :test do
+  gem 'webrat'
+  gem "rspec-rails", ">= 2.0.0.beta.19"
+end

data/full-examples/rest_from_scratch/part_1/README

@@ -0,0 +1,256 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.find(:all)
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.com/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |   |-- images
+  |   |-- javascripts
+  |   `-- stylesheets
+  |-- script
+  |   `-- performance
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Contains subdirectories for
+  images, stylesheets, and javascripts. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.