dope 0.0.2

data/Rakefile

@@ -0,0 +1,63 @@
+
+require 'rubygems'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift('lib')
+require 'dope'
+
+spec = Gem::Specification.new do |s|
+
+        s.name = 'dope'
+        s.rubyforge_project = 'dope'
+        s.version = Dope::VERSION
+        s.author = Dope::AUTHORS.first
+        s.homepage = Dope::WEBSITE
+        s.summary = "A way to export Welo resources on Derailleur"
+        s.email = "crapooze@gmail.com"
+        s.platform = Gem::Platform::RUBY
+
+        s.files = [
+          'Rakefile', 
+          'TODO', 
+          'lib/dope.rb',
+          'lib/dope/core/application.rb',
+          'lib/dope/core/context.rb',
+          'lib/dope/core/handler.rb',
+          'lib/dope/core/resource.rb',
+          'lib/dope/core/view.rb',
+        ]
+
+        s.require_path = 'lib'
+        s.bindir = 'bin'
+        s.executables = []
+        s.has_rdoc = true
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+        pkg.need_tar = true
+end
+
+task :gem => ["pkg/#{spec.name}-#{spec.version}.gem"] do
+        puts "generated #{spec.version}"
+end
+
+
+desc "run an example"
+task :example, :ex, :server, :port do |t, params|
+  path = "./example/#{params[:ex]}.rb"
+  servername = params[:server] || 'thin' 
+  port = params[:port] || '3000' 
+  if File.file? path
+    require path
+    require 'rack'
+    app = Rack::Builder.new {
+      run ExampleApplication
+    }
+    server = Rack::Handler.get(servername)
+    server.run(app, :Port => port.to_i)
+  else
+    puts "no such example: #{path}
+    use ls example to see the possibilities"
+   
+  end
+end

data/TODO

@@ -0,0 +1,16 @@
+* specs
+* static file handler
+  - create a class generator instead of current one and only one static approach
+  - better mime-types handling
+* export resource models 
+  - relations: get the data from the relationship:
+      -> currently values to iterate on are passed as parameters
+      -> we could get them from the relationship
+      -> ideally, the model could also be taken internally
+  - epithet
+      -> handler for epithet, current model handler uses match?, we will need to use
+          epithet_resource_match_params?
+* use perspectives in the handlers
+  - possibility to export one resource with a limited number of perspectives?
+* (unlikely) case which may break
+  - multiple nesting of similar resources => risk of parameter namespacing issue?

data/lib/dope/core/application.rb

@@ -0,0 +1,185 @@
+
+require 'derailleur'
+require 'dope/core/handler'
+autoload :Find, 'find'
+
+module Dope
+  module Application
+    include Derailleur::Application
+
+    def get_resource_at_path(resource, path)
+      puts "R: #{path}"
+      get(path, ResourceHandler.new(resource))
+    end
+
+    def get_resource(resource, root='', ident=:default)
+      path = File.join(root, resource.path(ident))
+      get_resource_at_path(resource, path)
+    end
+
+    def unget_resource(resource, root='', ident=:default)
+      path = File.join(root, resource.path(ident))
+      unget(path)
+    end
+
+    def get_linked_resource(link, root='')
+      branch = link.to_s.sub(/^\.\//,'')
+      path = File.join(root, branch)
+      get_resource_at_path(link.to, path)
+    end
+
+    def unget_linked_resource(link, root='')
+      branch = link.to_s.sub(/^\.\//,'')
+      path = File.join(root, branch)
+      unget(path)
+    end
+
+    def get_resource_relation(resource, relname, root='', ident=:default)
+      rel = resource.relationship(relname)
+      raise ArgumentError, "no relationship: #{relname} for #{resource}" unless rel
+      link = resource.link_for_rel(rel)
+      path = File.join(root, resource.path(ident))
+      case link
+      when Welo::Link
+        get_linked_resource(link, path)
+      when Welo::LinksEnumerator
+        link.each do |l|
+          get_linked_resource(l, path)
+        end
+      else
+        raise RuntimeError, "unknown kind of link: #{link}"
+      end
+    end
+
+    def unget_resource_relation(resource, relname, root='', ident=:default)
+      rel = resource.relationship(relname)
+      raise ArgumentError, "no relationship: #{relname} for #{resource}" unless rel
+      link = resource.link_for_rel(rel)
+      path = File.join(root, resource.path(ident))
+      case link
+      when Welo::Link
+        unget_linked_resource(link, path)
+      when Welo::LinksEnumerator
+        link.each do |l|
+          unget_linked_resource(l, path)
+        end
+      else
+        raise RuntimeError, "unknown kind of link: #{link}"
+      end
+    end
+
+    def get_resource_model_at_path(model, ident, resources, path)
+      puts "M: #{path}"
+      get(path, ResourceModelHandler.new([model, ident, resources]))
+    end
+
+    def get_resource_model(model, resources, root='', ident=:default)
+      path = File.join(root, model.path_model(ident, "#{model.base_path}."))
+      get_resource_model_at_path(model, ident, resources, path)
+    end
+
+    def unget_resource_model(model, root='', ident=:default)
+      path = File.join(root, model.path_model(ident, "#{model.base_path}."))
+      unget(path)
+    end
+
+    def get_resource_nesting_model(resource, relname, model, resources, root='', ident=:default)
+      nesting = resource.nesting(relname)
+      raise ArgumentError, "no nesting: #{relname} for #{resource}" unless nesting
+      model_ident = nesting.identifier_sym
+      path = File.join(root, resource.path(ident))
+      get_resource_model(model, resources, path, model_ident)
+    end
+
+    def unget_resource_nesting_model(resource, relname, model, root='', ident=:default)
+      nesting = resource.nesting(relname)
+      raise ArgumentError, "no nesting: #{relname} for #{resource}" unless nesting
+      model_ident = nesting.identifier_sym
+      path = File.join(root, resource.path(ident))
+      unget_resource_model(model, path, model_ident)
+    end
+
+    def get_resource_epitheting_model(resource, label, model, resources, root='', ident=:default)
+      epithet = resource.epithet(label)
+      raise ArgumentError, "no epithet: #{label} for #{resource}" unless epithet
+      branch = resource.epithets(label, "#{model.base_path}.")
+      path = File.join(root, resource.path(ident), label.to_s, branch)
+      get_resource_epitheting_model_at_path(resource, model, label, resources, path)
+    end
+
+    def get_resource_epitheting_model_at_path(resource, model, label, resources, path)
+      puts "E: #{path}"
+      get(path, ResourceEpithetingModelHandler.new([model, label, resources, resource]))
+    end
+
+    # multi-level
+
+    def get_resource_relation_tree(resource, tree=[], root='', ident=:default)
+      path = if ident
+               File.join(root, resource.path(ident))
+             else
+               root
+             end
+      tree.each do |node|
+        relname, subtree = if node.is_a? Array
+                             [node.first, node[1 .. -1]]
+                           else
+                             [node, []]
+                           end
+        rel = resource.relationship(relname)
+        raise ArgumentError, "no relationship: #{relname} for #{resource}" unless rel
+        link = resource.link_for_rel(rel)
+        case link
+        when Welo::Link
+          get_linked_resource(link, path)
+          unless subtree.empty?
+            branch = link.to_s.sub(/^\.\//,'')
+            new_root = File.join(path, branch)
+            get_resource_relation_tree(link.to, subtree, new_root, nil)
+          end
+        when Welo::LinksEnumerator
+          link.each do |l|
+            get_linked_resource(l, path)
+            unless subtree.empty?
+              branch = link.to_s.sub(/^\.\//,'')
+              new_root = File.join(path, branch)
+              get_resource_relation_tree(link.to, subtree, new_root, nil)
+            end
+          end
+        else
+          raise RuntimeError, "unknown kind of link: #{link}"
+        end
+      end
+    end
+
+    def get_resource_relation_chain(resource, relnames=[], root='', ident=:default)
+      tree = []
+      last = tree
+      relnames.each do |sym|
+        ary = [sym]
+        last << ary
+        last = ary
+      end
+      get_resource_relation_tree(resource, tree, root, ident)
+    end
+
+
+    # file-system assets' handling
+
+    def static_dir(dir)
+      Find.find(dir) do |path|
+        if File.file?(path)
+          static_file path, dir
+        end
+      end
+    end
+
+    def static_file(path, dir='')
+      route = path.sub(dir,'')
+      puts "F: #{route}"
+      StaticFileHandler.register(route, path)
+      get(route.sub(/\.\w+$/,''), StaticFileHandler)
+    rescue Derailleur::RouteObjectAlreadyPresent
+    end
+  end
+end

data/lib/dope/core/context.rb

@@ -0,0 +1,60 @@
+
+autoload :Rack, 'rack/utils'
+require 'derailleur/base/context'
+require 'mime/types'
+
+module Dope
+  class ResourceContext < Derailleur::Context
+    attr_reader :resource
+    def initialize(env, ctx, resource, &blk)
+      super(env, ctx, &blk)
+      @resource = resource
+    end
+
+    def perspective
+      (Rack::Utils.parse_query(env['QUERY_STRING'])['perspective'] || 'default').to_sym
+    end
+
+    def default_ext
+      '.html'
+    end
+
+    def default_content_type
+      'text/plain'
+    end
+
+    def ext
+      ret = extname 
+      return default_ext if ret.empty?
+      ret
+    end
+
+    #XXX bitchy: all the if ext == '.html' may go to the code in the view
+    def content
+      e = ext
+      if e == '.html'
+        resource.view.render(self)
+      else
+        resource.to_ext(e, self)
+      end
+    end
+
+    def mime_types
+      MIME::Types.of(ext)
+    end
+
+    def content_type
+      m = mime_types
+      if m
+        m.first.to_s 
+      else
+        default_content_type
+      end
+    end
+
+    def headers
+      {'Content-Type' => content_type}
+    end
+
+  end
+end

data/lib/dope/core/handler.rb

@@ -0,0 +1,105 @@
+
+require 'dope/core/context'
+require 'derailleur/core/handler'
+require 'mime/types'
+
+module Dope
+  class StaticFileHandler < Derailleur::RackHandler
+    class NoSuchStaticFile < Derailleur::NoSuchRoute
+    end
+
+    @registrations = {}
+
+    class << self
+      attr_reader :registrations
+
+      def register(route, path)
+        registrations[route] = path
+      end
+    end
+
+    def path
+      self.class.registrations[env['PATH_INFO']]
+    end
+
+    def extname
+      File.extname(env['PATH_INFO'])
+    end
+
+    def mime_types
+      MIME::Types.of(path)
+    end
+
+    def content_type
+      m = mime_types
+      m.first.to_s if m
+    end
+
+    def to_rack_output
+      raise NoSuchStaticFile, "no such file (#{path}) for #{env['PATH_INFO']}" unless path and File.file?(path)
+      [200, {'Content-Type' => content_type}, File.read(path)]
+    end
+  end
+
+  class ResourceHandler < Derailleur::Handler
+    alias :resource :object
+
+    def to_rack_output
+      context = ResourceContext.new(env, ctx, resource)
+      context.result
+    end
+  end
+
+  class ResourceNotFound < Derailleur::NoSuchRoute
+  end
+
+  class ResourceModelHandler < Derailleur::Handler
+    def model
+      object[0]
+    end
+
+    def resources
+      object[2]
+    end
+
+    def prefix
+      ":#{model.base_path}."
+    end
+
+    def to_rack_output
+      resource = find_resource
+      raise ResourceNotFound unless resource
+      ResourceHandler.new(resource, env, ctx).to_rack_output
+    end
+  end
+
+  class ResourceNestingModelHandler < ResourceModelHandler
+    def ident
+      object[1]
+    end
+
+    def find_resource
+      params = ctx['derailleur.params'].dup
+      params.delete(:splat)
+      resources.find{|r| r.match_params?(params, ident, prefix)}
+    end
+  end
+
+  class ResourceEpithetingModelHandler < ResourceModelHandler
+    def label
+      object[1]
+    end
+
+    def resource
+      object[3]
+    end
+
+    def find_resource
+      params = ctx['derailleur.params'].dup
+      params.delete(:splat)
+      found = resources.find do |r|
+        resource.epithet_resource_match_params?(r, params, label, prefix)
+      end
+    end
+  end
+end

data/lib/dope/core/resource.rb

@@ -0,0 +1,30 @@
+
+require 'welo'
+
+module Dope
+  autoload :View, 'dope/core/view'
+  module Resource
+    include Welo::Resource
+    def self.included(mod)
+      mod.extend Welo::Resource::ClassMethods
+      mod.extend ClassMethods
+    end
+
+    module ClassMethods
+      def view(val=nil)
+        if val
+          @view = val
+        end
+        @view
+      end
+    end
+
+    def view_klass
+      self.class.view
+    end
+
+    def view
+      view_klass.new(self)
+    end
+  end
+end

data/lib/dope/core/view.rb

@@ -0,0 +1,13 @@
+
+module Dope
+  class View
+    attr_reader :resource
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def render(ctx)
+      "hello from #{self} for #{resource} in #{ctx}"
+    end
+  end
+end

data/lib/dope.rb

@@ -0,0 +1,10 @@
+
+module Dope
+  VERSION = "0.0.2"
+  AUTHORS = ["crapooze"]
+  WEBSITE = "https://github.com/crapooze/dope"
+  LICENCE = "MIT"
+  autoload :Application, 'dope/core/application'
+  autoload :Resource, 'dope/core/resource'
+  autoload :View, 'dope/core/view'
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: dope
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- crapooze
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-14 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: crapooze@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- TODO
+- lib/dope.rb
+- lib/dope/core/application.rb
+- lib/dope/core/context.rb
+- lib/dope/core/handler.rb
+- lib/dope/core/resource.rb
+- lib/dope/core/view.rb
+has_rdoc: true
+homepage: https://github.com/crapooze/dope
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: dope
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A way to export Welo resources on Derailleur
+test_files: []
+