optionsful 0.1.2 → 0.1.5

data/lib/baurets/optionsful/version.rb

@@ -0,0 +1,16 @@
+module Baurets
+  module Optionsful
+    module Version
+
+      MAJOR = 0
+      MINOR = 1
+      TINY  = 5
+
+      def self.to_s
+        "#{MAJOR}.#{MINOR}.#{TINY}"
+      end
+
+    end
+
+  end
+end

data/lib/introspections.rb

@@ -0,0 +1,94 @@
+
+module Introspections
+
+
+
+  def self.guess_route(routes, path)
+    parts = prepare_request_path(path)
+    guess = []
+    index = 0
+    parts.each do |part|
+      if is_part_static?(routes, index, part)
+        guess << part
+      else
+        guess << :dynamic
+      end
+      index += 1
+    end
+    guess
+  end
+
+  def self.is_part_static?(routes, index, value)
+    routes.each do |route|
+      if route[0][index] == value
+        return true
+      end
+    end
+    return false
+  end
+
+  def self.do_routing_introspection
+    routes = []
+    route_requirements = nil
+    ActionController::Routing::Routes.routes.each do |route|
+      static_path = []
+      route.segments.each do |segment|
+        route_requirements = route.requirements #TODO validate 
+        if segment.kind_of?(ActionController::Routing::StaticSegment)
+          static_path << segment.value if (segment.respond_to?(:value) && segment.value != "/")
+        elsif segment.kind_of?(ActionController::Routing::DynamicSegment)
+          static_path << :dynamic unless (segment.respond_to?(:key) && segment.key == :format)   
+        end
+      end
+      routes << [static_path, [route.conditions[:method].to_s.upcase, route_requirements[:action]], route_requirements] unless route.conditions[:method].nil?
+    end
+    routes
+  end
+
+  def self.guess_route(routes, path)
+    parts = prepare_request_path(path)
+    guess = []
+    index = 0
+    parts.each do |part|
+      if is_part_static?(routes, index, part)
+        guess << part
+      else
+        guess << :dynamic
+      end
+      index += 1
+    end
+    guess
+  end
+
+  def self.discover_controller_name(path)
+    routes = do_routing_introspection
+    guess = guess_route(routes, path)
+    routes.each do |route|
+      if route[0] == guess
+        return route[2][:controller]
+      end
+    end
+    
+  end
+
+  def self.do_the_matches(routes, route_guess)
+    allow = ""
+    routes.each do |route|
+      if route.first == route_guess
+        allow += route[1][0].to_s.upcase + "|" 
+      end
+    end
+    allow = allow.split("|").join(", ")
+  end
+
+  def self.prepare_request_path(path)
+    unless path.kind_of? Array
+      path = path[0..(path.rindex('.')-1)] if path.include?('.')
+      path_parts = path.split("/")
+    else
+      path_parts = path
+    end
+    path_parts.delete("")
+    path_parts
+  end
+end

data/lib/optionsful.rb

@@ -1,90 +1,57 @@
+require File.join(File.dirname(__FILE__), 'introspections.rb')
 
-  class Optionsful  
 
-    def initialize(app)  
-      @app = app  
-    end  
+class Optionsful  
 
-    def call(env) 
-      unless env["REQUEST_METHOD"] == "OPTIONS"
-        @app.call(env)
-      else
-        extract_options_information(env)
-      end
-    end
-
-    private
+  
+  def initialize(app)  
+    @app = app
+    @doc = {:controller => nil, :actions => [] } # { :action => "index", :method => "GET" }, { :action => "create", :method => "POST" }
+  end  
 
-    def extract_options_information(env)
-      [204, {"Allow" => extract_allowed_methods(env), "Link" => build_help_link}, ""]  
+  def call(env) 
+    unless env["REQUEST_METHOD"] == "OPTIONS"
+      @app.call(env)
+    else
+      extract_options_information(env)
     end
+  end
 
-    def extract_allowed_methods(env)
-      # do routing introspection:
-      routes = do_routing_introspection
-      # do request path investigation
-      route_guess = guess_route(routes, env["PATH_INFO"])
-      allows = ""
-      # do the matches:
-      routes.each do |route|
-        if route.first == route_guess
-          allows += route[1].to_s.upcase! + "|" 
-        end
-      end
-      allows = allows.split("|").join(", ")
-    end
+  private
 
-    def build_help_link
-      #PENDING
-      "<http://baurets.net/api/resources>; type=text/html; rel=help"
-    end
+  def extract_options_information(env)
+    [204, {"Allow" => extract_allowed_methods(env), "Link" => build_help_link(env)}, ""]  
+  end
 
-    def guess_route(routes, path)
-      parts = prepare_request_path(path)
-      guess = []
-      index = 0
-      parts.each do |part|
-        if is_part_static?(routes, index, part)
-          guess << part
-        else
-          guess << :dynamic
-        end
-        index += 1
-      end
-      guess
-    end
+  def extract_allowed_methods(env)
+    # do routing introspection:
+    routes = Introspections.do_routing_introspection
+    # do request path investigation
+    route_guess = Introspections.guess_route(routes, env["PATH_INFO"])
+    # do the matches:
+    allow = do_the_matches(routes, route_guess)
+  end
 
-    def is_part_static?(routes, index, value)
-      routes.each do |route|
-        if route[0][index] == value
-          return true
-        end
-      end
-      return false
-    end
+  private
 
-    def do_routing_introspection
-      routes = []
-      ActionController::Routing::Routes.routes.each do |route|
-        static_path = []
-        route.segments.each do |segment|
-          if segment.kind_of?(ActionController::Routing::StaticSegment)
-            static_path << segment.value if (segment.respond_to?(:value) && segment.value != "/")
-          elsif segment.kind_of?(ActionController::Routing::DynamicSegment)
-            static_path << :dynamic unless (segment.respond_to?(:key) && segment.key == :format)   
-          end
-        end
-        routes << [static_path, route.conditions[:method]] unless route.conditions[:method].nil?
+  def do_the_matches(routes, route_guess)
+    allow = ""
+    routes.each do |route|
+      if route.first == route_guess
+        allow += route[1][0].to_s.upcase + "|" 
+        @doc[:controller] = route[2][:controller]
+        @doc[:actions] << { :action => (route[2][:action]), :method => (route[1].to_s.upcase!) }
       end
-      routes
-    end
-
-    def prepare_request_path(path)
-      path = path[0..(path.rindex('.')-1)] if path.include?('.')
-      path_parts = path.split("/")
-      path_parts.delete("")
-      path_parts
     end
+    allow = allow.split("|").join(", ")
+  end
 
+  def build_help_link(env)
+    server_name = env["SERVER_NAME"]
+    server_port = env["SERVER_PORT"]
+    "<http://#{server_name}:#{server_port}/opts#{env["PATH_INFO"]}>; type=text/html; rel=help"
   end
 
+
+
+end

data/lib/optionsful_docs.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'yard'
+require 'rdoc/rdoc'
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'introspections.rb')
+
+class OptionsfulDocs
+
+
+  def initialize(app)  
+    @app = app
+  end  
+
+  def call(env) 
+    unless env["PATH_INFO"].index("/opts/") == 0
+      @app.call(env)
+    else
+      extract_documentation(env)
+    end
+  end
+
+  def extract_documentation(env)
+
+    parts = env["PATH_INFO"].split("/")
+    parts.delete("")
+    parts.delete("opts")
+    # do routing introspection:
+    routes = Introspections.do_routing_introspection
+    # do request path investigation
+    path = parts.join("/")
+    puts "\n #{path} \n"
+    route_guess = Introspections.guess_route(routes,path)
+    # do the matches:
+    allow = Introspections.do_the_matches(routes, route_guess)
+    http_methods = allow.split(", ")
+
+    controller_actions = []
+    http_methods.each do |verb|
+      controller_actions << [verb, relate_action_to_method(parts, verb)]
+    end
+
+    controller_actions.delete_if {|pair| pair[1].empty? }
+    puts "controller_actions: #{controller_actions.inspect}"
+    controller_name = Introspections.discover_controller_name(parts) + "_controller"
+    file = File.join(RAILS_ROOT, "app", "controllers", controller_name + ".rb")
+    controller_class = controller_name.camelize
+
+    service_doc = extract_comments_above(file, find_line_for(file, controller_class, :class)).join("\n")
+
+    methods_docs = []
+    controller_actions.each do |info|
+      methods_docs << [info, extract_comments_above(file, find_line_for(file, info[1], :method)).join("\n")]
+    end
+
+    body = "\n\nService: \n" + service_doc + "\n" 
+    methods_docs.each do |md|
+      body += "\n\nMethod: #{md[0][0]} \n Action: #{md[0][1]} \n Metadata: \n #{md[1]}\n\n-- end ---\n"
+    end
+
+    [200, {}, "Under development!!! \n  #{body}"]
+  end
+
+  def relate_action_to_method(path, verb)
+    action = ""
+    routes = Introspections.do_routing_introspection
+    route_guess = Introspections.guess_route(routes, path)
+    routes.each do |route|
+      if ((route.first == route_guess) && (route[1][0] == verb))
+        action = route[1][1] unless route[1][1].empty?
+      end
+    end
+    action
+  end
+
+
+
+  def file_lines(file_name)
+    lines = []
+    begin
+      file = File.new(file_name, "r")
+      while (line = file.gets)
+        line = line.strip
+        lines << line unless line.empty?
+      end
+      file.close
+    rescue => err
+      puts "Exception: #{err}"
+      err
+    end
+    lines.delete(nil)
+    lines
+  end  
+
+  def extract_comments_above(file_name, line_number)
+    lines = file_lines(file_name)
+    doc = []
+    line_number = line_number -1
+    while ((line_number = line_number -1) && (line_number >= 0) && (!lines.nil?) && (!lines[line_number].empty?))
+      line = lines[line_number].lstrip
+      if line[0] == 35
+        doc << line
+        
+      else
+        line_number = 0
+      end 
+    end
+    doc.reverse
+    puts doc.inspect
+    doc
+  end
+
+  def find_line_for(file, name, type) 
+    lines = file_lines(file)
+    signature = ""
+    if type == :class
+      signature = "class " + name
+    elsif type == :method
+      signature = "def " + name
+    end
+    counter = 1;
+    lines.each do |line|
+      if line.include? signature
+        return counter
+      end
+      counter += 1
+    end
+  end
+
+end

data/rails/init.rb

@@ -1,2 +1,15 @@
 # Adding Optionsful to the Rack middleware stack:
-ActionController::Dispatcher.middleware.use Optionsful
+ActionController::Dispatcher.middleware.use Optionsful
+ActionController::Dispatcher.middleware.use OptionsfulDocs
+
+
+require 'rubygems'
+require 'yard'
+YARD::Templates::Engine.register_template_path File.dirname(__FILE__) + '/../templates'
+
+# Define custom tags
+YARD::Tags::Library.define_tag("URL for Service", :url)
+YARD::Tags::Library.define_tag("Topic for Service", :topic)
+YARD::Tags::Library.define_tag("Arguments", :argument, :with_types_and_name)
+YARD::Tags::Library.define_tag("Example Responses", :example_response)
+YARD::Tags::Library.define_tag("Response Fields", :response_field, :with_name)

data/spec/optionsful_docs_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe "OptionsfulDocs" do
+
+  include Rack::Test::Methods
+
+
+  describe "as a Rack middleware" do
+
+    it "is a Ruby object that responds to call;" do
+      assert OptionsfulDocs.new(app).respond_to? :call
+    end
+
+    it "takes exactly one argument, (the environment) and returns an Array;" do
+      response = OptionsfulDocs.new(app).call(mock_env({"REQUEST_METHOD" => "GET", "PATH_INFO" => "/opts/"}))
+      assert response.kind_of?(Array)
+    end
+
+    it "the returned Array must have exactly three values: the status, the headers and the body;" do
+      response = OptionsfulDocs.new(app).call(mock_env({"REQUEST_METHOD" => "GET", "PATH_INFO" => "/opts/"}))
+      assert response.size.should == 3
+      assert response[0].kind_of? Fixnum 
+      assert response[1].kind_of? Hash
+      assert response[2].kind_of? String
+    end
+
+    it "must be nice, acting somewhere on a Rack middleware stack." do
+      response = fake_docs_app.call(mock_env({"REQUEST_METHOD" => "GET", "PATH_INFO" => "/opts/"}))
+      assert response.size.should == 3
+      assert response[0].kind_of? Fixnum
+      assert response[0].should == 200
+      assert response[1].kind_of? Hash
+    end
+
+  end
+
+end

data/spec/optionsful_spec.rb

@@ -32,7 +32,7 @@ describe "Optionsful," do
     end
 
     it "must be nice, acting somewhere on a Rack middleware stack." do
-      response = fake_app.call(mock_env({"REQUEST_METHOD" => "OPTIONS", "PATH_INFO" => "/posts"}))
+      response = fake_opts_app.call(mock_env({"REQUEST_METHOD" => "OPTIONS", "PATH_INFO" => "/posts"}))
       assert response.size.should == 3
       assert response[0].kind_of? Fixnum
       assert response[0].should == 204
@@ -101,7 +101,7 @@ describe "Optionsful," do
 
     it " method GET example" do
       complex_env = mock_env({"REQUEST_METHOD" => "GET", "PATH_INFO" => "/lobster" })
-      response = fake_app.call(complex_env)
+      response = fake_opts_app.call(complex_env)
       assert response.kind_of?(Array)
       assert response.size.should == 3
     end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require File.join(File.dirname(__FILE__), '..', 'lib','optionsful.rb')
+require File.join(File.dirname(__FILE__), '..', 'lib','optionsful_docs.rb')
 
 require 'rubygems' 
 require 'sinatra' 
@@ -9,8 +10,7 @@ require 'spec'
 require 'spec/autorun' 
 require 'spec/interop/test' 
 require 'action_controller' 
-require 'ruby-debug'
-# require 'baurets/optionsful'
+
 
 # set test environment set :environment, :test set :run, false set :raise_errors, true set :logging, false
 
@@ -37,7 +37,7 @@ DEFAULT_ENV = { "rack.version" => Rack::VERSION, "rack.input" => StringIO.new, "
     end
 
 
-    def fake_app
+    def fake_opts_app
       app = Rack::Builder.new {
         use Rack::CommonLogger
         use Rack::ShowExceptions
@@ -48,6 +48,18 @@ DEFAULT_ENV = { "rack.version" => Rack::VERSION, "rack.input" => StringIO.new, "
         end
       }
     end
+    
+    def fake_docs_app
+      app = Rack::Builder.new {
+        use Rack::CommonLogger
+        use Rack::ShowExceptions
+        use OptionsfulDocs
+        map "/lobster" do
+          use Rack::Lint
+          run Rack::Lobster.new
+        end
+      }
+    end
 
     def mock_env(options = {})
       FAKE_ENV.merge!(options)
@@ -56,7 +68,6 @@ DEFAULT_ENV = { "rack.version" => Rack::VERSION, "rack.input" => StringIO.new, "
     def http_options_request(path)
       complex_env = mock_env({"REQUEST_METHOD" => "OPTIONS", "PATH_INFO" => path })
       response = Optionsful.new(app).call(complex_env)
-      response
     end
     
     def allows?(headers, method)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: optionsful
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 5
+  version: 0.1.5
 platform: ruby
 authors: 
 - Marco Antonio Gonzalez Junior
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-19 00:00:00 -03:00
+date: 2010-07-22 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -37,6 +37,10 @@ files:
 - spec/optionsful_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- lib/optionsful_docs.rb
+- lib/introspections.rb
+- lib/baurets/optionsful/version.rb
+- spec/optionsful_docs_spec.rb
 has_rdoc: true
 homepage: http://optionsful.rubyforge.org
 licenses: []