welo 0.0.6

data/README

@@ -0,0 +1,122 @@
+
+= Welo
+
+Welo is a library to work with resources in a general framework.
+It deals with the following concerns:
+  - relationships between resources
+  - structuring and access control with perspectives: one may or may not be able to access all fields of a resource
+  - identifiers and epithets
+  - serialization of resources
+
+== Perspectives
+
+When you look at a house, you usually can see walls, windows, a door, and a
+roof. If you can enter the house, then you will see rooms, furniture,
+inhabitants and so on. Depending on the room where you are, you will not see
+the roof. The concept of perspective is basically that: depending on where you
+look from (or who you are), you cannot observe the same parts of the same
+object. Perspectives have a name, and a set of symbols which corresponds to
+what someone can observe through this perspective.
+
+A piece of code for the above example could be:
+
+class House
+  include Welo::Resource
+  perspective :outside, [:walls, :windows, :roof, :door]
+  perspective :inside, [:rooms, :furniture, :inhabitants]
+end
+
+== Identifiers
+
+Say you have a lots of shirts, and picked one for a party. A close friend calls
+you and ask you which clothes you're taking. Then, you'll describe your shirt
+like "the black shirt with vertical stripes". You've just identified your
+shirt, by, giving enough information to uniquelly identify a shirt.  Then,
+depending on the situation, you may identify a shirt differently. As an
+example, the shop where you've bought your shirt has a reference number, and
+maybe a barcode to identify it.  By default, Welo will add a 'uuid' method
+(which is aliased to the object_id) for identifying a resource. You can always
+override that.
+
+class Shirt
+  include Welo::Resource
+  # identify :default, :uuid #what Welo does for you
+  identify :friend, :colors, :stripes, :length
+  identify :shop, :refnum
+end
+
+== Relationships
+
+Often, two things are related whith each other. With respect to the state of
+the art. So far, a person may have many shirts but has only two biological
+parents: a father and a mother. Currently, Welo has relationships of :one and
+:many kinds of relationships. This allow you to define some elaborate structures:
+
+class Person
+  include Welo::Resource
+  relationship :shirts, :Shirt, :many
+  relationship :father, :Person, :one
+  relationship :mother, :Person, :one
+end
+
+Someone used to relational system may notice that we only wrote one part of the
+relationships: if a person has another Person as a parent, therefore, the
+parents should have a sort of symmetrical relationship. For simplicity, Welo does not force you to write this symmetry relationship if you will not be using it in your program.
+Similarly, for now, there are no complex associations, like through
+associations. Welo's goal is not to build an ORM which optimizes SQL queries.
+
+Finally, there are two ways to qualify relationships: Nestings and Epithets.
+These two qualifiers are related to the various ways of identifying related
+resources.
+
+=== Nesting 
+Nestings, let you use an external way of identifying a resource. In that case,
+the resource identification's scheme depends on the resources, but the value of
+the identification is within the nested resource itself.  As an example, for a
+company, an employee will be identified upon its social security number,
+whereas, in a pub, friends will use his name.
+Nesting, just mark a preferred way of identifying related resources.
+
+class Person
+  include Welo::Resource
+  identify :friend, :name
+  identify :company, :ssn
+  relationship :friends, :Person, :many
+  nesting :friends, :friend
+end
+
+class Company
+  include Welo::Resource
+  relationship :employees, :Person, :many
+  nesting :employees, :company
+end
+
+=== Epithets
+Epithets are similar to nestings, but the way of identifying a resource is only
+related to the pointing resource.  As an example, a person may have three
+preferred movies. This naming scheme is only personal to the person, but not to
+the movies. So, if you know that an object has preferred movies, you don't need
+to know anything about the movie to identify it within the context of a person.
+For now, declaring requires you must first specify that the matching
+relationship is a mere alias, then declare the epithet's method for identifying
+the related resource.
+
+class Movie
+  include Welo::Resource
+end
+
+class Person
+  include Welo::Resource
+  relationship :preferred_movies, :Movie, :many, :alias
+  epithet :preferred_movies, :rank_for_preffered_movie
+
+  def rank_for_preffered_movie(movie)
+    @preferred_movies.index(movie)
+  end
+end
+
+== Coming later
+
+* Embedding (similar to mongo's embedded documents).
+* ResourceProxys to manipulate distant resources, or resources observed from one perspective, with missing fields.
+

data/Rakefile

@@ -0,0 +1,45 @@
+
+require 'rubygems'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift('lib')
+require 'welo'
+
+spec = Gem::Specification.new do |s|
+        s.name = 'welo'
+        s.rubyforge_project = 'welo'
+        s.version = Welo::VERSION
+        s.author = Welo::AUTHORS.first
+        s.homepage = Welo::WEBSITE
+        s.summary = "A light resource model for Ruby"
+        s.email = "crapooze@gmail.com"
+        s.platform = Gem::Platform::RUBY
+
+        s.files = [
+          'Rakefile', 
+          'TODO', 
+          'README',
+          'lib/welo.rb',
+          'lib/welo/core/resource.rb',
+          'lib/welo/core/relationship.rb',
+          'lib/welo/core/link.rb',
+          'lib/welo/core/matcher.rb',
+          'lib/welo/core/nesting.rb',
+          'lib/welo/core/perspective.rb',
+          'lib/welo/base/resource.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
+

data/TODO

@@ -0,0 +1,8 @@
+* Relationships
+  - we have :one, :many, we should be able to have, exactly_four, or one_per_foo
+* Epitheting vs. Nesting vs. Identifying
+  - remove alias from Relationship and create a similar Epiteth object?
+* Embeddings
+  - recursively embedded datastructures?
+  - how to work with perspectives?
+* ResourceProxy

data/lib/welo.rb

@@ -0,0 +1,8 @@
+
+module Welo
+  VERSION = "0.0.6"
+  AUTHORS = ['crapooze']
+  WEBSITE = "http://github.com/crapooze/welo"
+  LICENCE = "MIT"
+  autoload :Resource, 'welo/base/resource'
+end

data/lib/welo/base/resource.rb

@@ -0,0 +1,69 @@
+
+require 'welo/core/resource'
+module Welo
+  module Resource
+
+    # returns a text representation of the resource, under
+    # the persp perspective, 
+    # the format is not standardized, suitable for dev cycles
+    def to_text(persp)
+      ret = ''
+      structure_pairs(persp).each do |k,val|
+        ret << "##{k}\n"
+        if val.respond_to? :map
+          ret << val.map{|v| v.to_s}.join("\n")
+        else
+          ret << val.to_s
+        end
+        ret << "\n"
+      end
+      ret
+    end
+
+    # returns an array of pairs of fields name and fields values 
+    # for the perspective.
+    #
+    # the order of the pairs is the same as the fields in the perspective
+    #
+    # Links to other resources are represented as urls by sending
+    # them the :to_s method.
+    # the name of this method comes from the fact that Links are serialized to
+    # strings
+    def serialized_pairs(persp)
+      ary = structure_pairs(persp).map do |sym, val|
+        i1 = case val
+             when Link
+               val.to_s
+             when LinksEnumerator
+               val.map{|v| v.to_s}
+             else
+               val
+             end
+        [sym, i1]
+      end
+    end
+
+    # similar to to_rb_hash, but with the urls serialized
+    def to_serialized_hash(persp)
+      Hash[serialized_pairs(persp)]
+    end
+
+    # returns a JSON representation of the resource, under
+    # the persp perspective
+    def to_json(persp)
+      to_serialized_hash(persp).to_json
+    end
+
+    # returns a YAML representation of the resource, under
+    # the persp perspective
+    def to_YAML(persp)
+      YAML.dump to_serialized_hash(persp)
+    end
+
+    # shortcut to call  to_#{ext}
+    def to_ext(ext, persp=:default)
+      meth = ext.sub(/^\./, 'to_')
+      send(meth, persp)
+    end
+  end
+end

data/lib/welo/core/link.rb

@@ -0,0 +1,123 @@
+
+module Welo
+  module CanBeLazy
+    # A flag to say if this object is lazy or not
+    attr_accessor :lazy
+
+    # A hash of blocks between methods name and lazy evaluations
+    attr_accessor :lazy_blocks
+
+    def lazy_blocks
+      @lazy_blocks ||= {}
+    end
+
+    # true if lazy
+    def lazy?
+      (@lazy && true) or @lazy.nil?
+    end
+  end
+
+  class Link
+    include CanBeLazy
+
+    # The pointing resource
+    attr_accessor :from
+
+    # The pointed resource
+    attr_accessor :to
+
+    # The labeling for this link
+    attr_accessor :label
+
+    # The locality for this link
+    attr_accessor :local
+
+    # Creates a link to the pointed resource to,
+    # it must respond to :path
+    def initialize(from, to=nil, params={}, &blk)
+      @from = from
+      @to = to
+      @lazy = params.has_key?(:lazy) ? params[:lazy] : true
+      @label = params[:label] 
+      @local = params[:local] 
+      lazy_blocks[:to] = blk if block_given?
+    end
+
+    # If the link is lazy and there is no value to @to,
+    # will evaluate the :to lazy_block and set to to this value.
+    # If the link is not lazy, will just return @to
+    def to
+      if @lazy
+        @to ||= lazy_blocks[:to].call
+      else
+        @to
+      end
+    end
+
+    # Gets the nesting of the from resource of this link.
+    def nesting
+      @nesting ||= from.nesting(label)
+    end
+
+    # Gets the identifying scheme corresponding to this link.
+    # For now the identification scheme is written in the to resource.
+    # Later, we'll try to be able to identify pointed resources with
+    # an identifying scheme local to the from resource.
+    def identify
+      identify = if nesting
+                   nesting.identifier_sym
+                 else
+                   :default
+                 end
+    end
+
+    # Returns an absolute version of the path.
+    # Meaning that we use the default identifying scheme.
+    def to_absolute_path
+      File.join('', to.path(:default).to_s)
+    end
+
+    # Returns a relative version of the path.
+    # We can use a different identification scheme of the pointed resource.
+    # Later, we'll try to be able to identify pointed resources with
+    # a identifying scheme local to the from resource.
+    def to_relative_path
+      File.join('.', to.path(identify).to_s)
+    end
+
+    def to_local_path
+      File.join('.', from.epithet_path_to(to, label).to_s)
+    end
+
+    # Returns a string representation of this link
+    # (i.e., an path)
+    def to_s
+      if nesting
+        to_relative_path
+      elsif local
+        to_local_path
+      else
+        to_absolute_path
+      end
+    end
+  end
+
+  class LinksEnumerator
+    include Enumerable
+
+    # the enumerating object
+    attr_reader :enum
+
+    def initialize(enum=nil, params={}, &blk)
+      @enum = enum || blk
+    end
+
+    def each
+      if enum.respond_to? :call
+        enum.call{|i| yield(i)}
+      else
+        enum.each{|i| yield(i)}
+      end
+    end
+  end
+end

data/lib/welo/core/matcher.rb

@@ -0,0 +1,101 @@
+
+module Welo
+  class Matcher
+    attr_reader :params, :prefix
+
+    # Initializes a new matcher for the set of params (a hash) a prefix may be
+    # given, in which case, only the keys prefixed by the prefix
+    # will be selected.
+    def initialize(params, prefix='')
+      @prefix = prefix.dup.freeze
+      @params = if prefix.empty?
+        params.dup.freeze
+      else
+        h = {}
+        keys = params.keys.select do |k|
+          k.start_with?(prefix)
+        end
+        keys.each do |k|
+          h[k] = params[k]
+        end
+        h.freeze
+      end
+    end
+
+    def missing_params?(*args)
+      missing_params(*args).any?
+    end
+
+    def too_many_params?(*args)
+      extra_params(*args).any?
+    end
+
+    def wrong_params_set?(*args)
+      missing_params?(*args) or 
+      too_many_params?(*args)
+    end
+
+  end
+
+  class IdentifyingMatcher < Matcher
+    def identifiers_for_params_matching(resource, ident=:default)
+      resource.identifiers(ident, prefix).map{|id| id.sub(/^:/,'')}
+    end
+
+    def missing_params(resource, ident=:default)
+      (identifiers_for_params_matching(resource, ident) - params.keys)
+    end
+
+    def extra_params(resource, ident=:default)
+      (params.keys - identifiers_for_params_matching(resource, ident))
+    end
+
+    # Returns true if the params hash qualifies for identifying this resource.
+    # prefixing is possible in case the hash's keys has prefixes
+    # e.g., Foo = Struct.new(:a, :b) do
+    #         include Resource
+    #         identify :default, :a, :b
+    #       end
+    #      foo = Foo.new(1,2)
+    #      params = { 'bla.a' => 1, 'bla.b' => 2 }
+    #      Matcher.new(params, 'bla.').match?(foo, :default) 
+    #      # => true
+    # see Resource#identifiers and identifiers_for_params_matching for more on prefix.
+    def match?(resource, ident=:default)
+      return false if wrong_params_set?(resource, ident)
+      pairs = [resource.identify(ident), identifiers_for_params_matching(resource, ident)].transpose
+      pairs.inject(true) do |bool, pair|
+        sym, param_name = *pair
+        bool and resource.send(sym) == params[param_name]
+      end
+    end
+
+    alias :=~ :match?
+  end
+
+  class EpithetMatcher < Matcher
+    def epithets_for_params_matching(resource, epithet_resource, label)
+      resource.epithets(label, prefix).map{|id| id.sub(/^:/,'')}
+    end
+
+    def missing_params(resource, epithet_resource, label)
+      (epithets_for_params_matching(resource, epithet_resource, label) - params.keys)
+    end
+
+    def extra_params(resource, epithet_resource, label)
+      (params.keys - epithets_for_params_matching(resource, epithet_resource, label))
+    end
+
+    def match?(resource, epithet_resource, label)
+      return false if wrong_params_set?(resource, epithet_resource, label)
+      pairs = [resource.epithet(label), 
+        epithets_for_params_matching(resource, epithet_resource, label)].transpose
+      pairs.inject(true) do |bool, pair|
+        sym, param_name = *pair
+        bool and resource.send(sym, epithet_resource) == params[param_name]
+      end
+    end
+
+    alias :=~ :match?
+  end
+end

data/lib/welo/core/nesting.rb

@@ -0,0 +1,19 @@
+
+module Welo
+  # Nesting are not embeddings they just points to other resources with local
+  # identification namings scheme
+  class Nesting
+    # The symbol for the method to call to get the 
+    # nested resource
+    attr_accessor :resource_sym
+
+    # The symbol for the method to identify the
+    # nested resource
+    attr_accessor :identifier_sym
+
+    def initialize(sym1, sym2)
+      @resource_sym = sym1
+      @identifier_sym = sym2
+    end
+  end
+end

data/lib/welo/core/perspective.rb

@@ -0,0 +1,12 @@
+
+module Welo
+  class Perspective
+    attr_reader :name
+    attr_reader :fields #symbols or relationships?
+
+    def initialize(name, fields)
+      @name = name
+      @fields = fields
+    end
+  end
+end

data/lib/welo/core/relationship.rb

@@ -0,0 +1,44 @@
+
+module Welo
+  class Relationship
+    # The symbol for the method to call to get the 
+    # related resource
+    attr_accessor :sym
+
+    # The kinds of relationship
+    attr_accessor :kinds
+
+    # The klass of the related resource
+    attr_accessor :klass
+
+    # Returns true if the kinds are incompatible
+    # current incompatibilities:
+    # - :one and :many at the same time
+    def self.incompatible_kinds?(kinds)
+      (kinds & [:one, :many]).size == 2
+    end
+
+    # creates a new relationship for sym and klass, with all the given kinds
+    # providing incompatibles kinds lead to an ArgumentError
+    def initialize(sym, klass, kinds)
+      raise ArgumentError, "incompatible kinds" if self.class.incompatible_kinds?(kinds)
+      @sym = sym
+      @klass = klass
+      @kinds = kinds
+    end
+
+    # true if at least one of the kinds is :one
+    def one?
+      kinds.include?(:one)
+    end
+
+    # true if at least one of the kinds is :many
+    def many?
+      kinds.include?(:many)
+    end
+
+    def alias?
+      kinds.include?(:alias)
+    end
+  end
+end

data/lib/welo/core/resource.rb

@@ -0,0 +1,319 @@
+
+module Welo
+  autoload :Link, 'welo/core/link'
+  autoload :LinksEnumerator, 'welo/core/link'
+  autoload :Relationship, 'welo/core/relationship'
+  autoload :Perspective, 'welo/core/perspective'
+  autoload :Nesting, 'welo/core/nesting'
+  autoload :IdentifyingMatcher, 'welo/core/matcher'
+  autoload :EpithetMatcher, 'welo/core/matcher'
+
+  module Resource
+
+    # A simple hook to extend the ClassMethods
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+
+    module ClassMethods
+      # A hook to duplicates 
+      # * relationships
+      # * perspectives 
+      # * identification
+      # * base_path
+      # Such that the subclass looks like the parent one
+      def inherited(klass)
+        relationships.each_pair do |k,v|
+          klass.relationships[k] = v
+        end
+        nestings.each_pair do |k,v|
+          klass.nestings[k] = v
+        end
+        perspectives.each_pair do |k,v|
+          klass.perspectives[k] = v
+        end
+        identifiers_hash.each_pair do |k,v|
+          klass.identifiers_hash[k] = v
+        end
+        klass.base_path base_path
+      end
+
+      # The hash of relationships with other resources
+      def relationships
+        @relationships ||= {}
+      end
+
+      # The hash of nestings of other resources
+      def nestings
+        @nestings ||= {}
+      end
+
+      # If one argument, returns the relationship with the given name
+      # If more than one argument, registers a new relationship,
+      # possibly overwriting it.
+      def relationship(sym, klass=nil, kinds=[])
+        if klass
+          relationships[sym] = Relationship.new(sym, klass, kinds)
+        else
+          relationships[sym]
+        end
+      end
+
+      # The hash of perspectives for this resource.
+      def perspectives
+        @perspectives ||= {}
+      end
+
+      # If one argument, returns the perspective for the given name, 
+      # or the :default one if it exists
+      # If more than one argument, registers a new perspective
+      def perspective(name, syms=nil)
+        if syms.nil?
+          perspectives[name] || perspectives[:default]
+        else
+          perspectives[name] = Perspective.new(name, syms)
+        end
+      end
+
+      # If one argument, returns the nesting for the given resource_sym
+      # If two arguments: creates a nesting of a resource in this resource
+      def nesting(resource_sym, identifier_sym=nil)
+        if identifier_sym.nil?
+          nestings[resource_sym]
+        else
+          nestings[resource_sym] = Nesting.new(resource_sym, identifier_sym)
+        end
+      end
+
+      # Returns the downcased last part of the ruby name
+      def default_base_path_name
+        self.name.split('::').last.downcase
+      end
+
+      # If there is one argument, sets the base_path,
+      # otherwise returns the base_path, if not set, will fallback to
+      # the default_base_path_name
+      def base_path(val=nil)
+        if val
+          @base_path = val
+        else
+          @base_path || default_base_path_name
+        end
+      end
+
+      # An hash to log the identifiers, by default, uses [:uuid]
+      def identifiers_hash
+        @identifiers_hash ||= {:default => [:uuid]}
+      end
+
+      # If there is no argument, returns the identification fields 
+      # (defaults to [:uuid]).
+      # Otherwise, sets the identification fields.
+      # Fields are symbols of methods that will be sent to the instances.
+      # Since they may be used to build an URL, identifying fields
+      # must respond to :to_s.
+      # See Resource#identifying_path_part
+      def identify(sym, vals=nil)
+        if vals.nil?
+          identifiers_hash[sym]
+        else
+          identifiers_hash[sym] = vals
+        end
+      end
+
+      # Returns array of formatted strings from the identification fields.
+      # a prefix may be appended before the identification field 
+      # e.g.
+      # 'foo' (no prefix) => 'foo'
+      # 'foo' (prefix:'bla.') => 'bla.foo'
+      def identifiers(ident, prefix='')
+        identify(ident).map{|sym| "#{prefix}#{sym}"}
+      end
+
+      def epithets_hash
+        @epithets_hash ||= {}
+      end
+
+      def epithet(sym, vals=nil)
+        if vals.nil?
+          epithets_hash[sym]
+        else
+          epithets_hash[sym] = vals
+        end
+      end
+
+      # Returns array of formatted strings from the epithets fields.
+      # a prefix may be appended before the epithets field 
+      # e.g.
+      # 'foo' (no prefix) => 'foo'
+      # 'foo' (prefix:'bla.') => 'bla.foo'
+      def epithets(label, prefix='')
+        epithet(label).map{|sym| "#{prefix}#{sym}"}
+      end
+
+      # Returns the path model for items of this resource, 
+      # including an optional prefix
+      # e.g. class Foo
+      #        base_path 'foo'
+      #        identify :default, :bar
+      #      end
+      #
+      #      Foo.path_model(ident, 'pfx.')
+      #      #=> 'foo/:pfx.bar'
+      def path_model(ident, prefix='')
+        File.join(base_path, identifiers(ident, ':' + prefix))
+      end
+
+      # Returns the structure associated to the selected perspective
+      # the structure replace the perspective's fields by relationships whenever
+      # it's possible
+      def structure(name)
+        persp = perspective(name)
+        raise ArgumentError.new("no such perspective: #{name} for #{self}") unless persp
+        fields = persp.fields
+        fields.map do |field|
+          rel = relationship(field)
+          (rel || field)
+        end
+      end
+    end # ClassMethods
+
+    # Shorthand for class' base_path
+    def base_path
+      self.class.base_path
+    end
+
+    # Shorthand for class' path_model
+    def path_model(ident=:default, prefix='')
+      self.class.path_model(ident, prefix)
+    end
+
+    # Shorthand for class' identify
+    def identify(ident=:default)
+      self.class.identify(ident)
+    end
+
+    # Shorthand for class' epithet
+    def epithet(name)
+      self.class.epithet(name)
+    end
+
+    # Shorthand for class' perspective
+    def perspective(sym)
+      self.class.perspective(sym)
+    end
+
+    # Shorthand for class' relationship
+    def relationship(sym)
+      self.class.relationship(sym)
+    end
+
+    # Shorthand for class' nesting
+    def nesting(resource_sym)
+      self.class.nesting(resource_sym)
+    end
+
+    # Returns the resource's path part mapping the various fields.
+    # The objects must respond to .to_s and return a value such that
+    # the URL part is valid (esp. no whitespace)
+    # This method does NOT check wether the return of .to_s builds a
+    # valid URL part
+    def identifying_path_part(ident=:default)
+      File.join identify(ident).map{|sym| send(sym).to_s}
+    end
+
+    # Returns the full URL of this object
+    def path(ident=:default)
+      tail = identifying_path_part(ident)
+      if tail.empty?
+        base_path
+      else
+        File.join base_path, tail
+      end
+    end
+
+    # Same as Resource.identifiers
+    def identifiers(ident=:default, prefix='')
+      identify(ident).map{|sym| ":#{prefix}#{sym}"}
+    end
+
+    # Shorthand for class' structure
+    def structure(name)
+      self.class.structure(name)
+    end
+
+    # Returns the structure as an array of pairs which first object is the
+    # field name, the second object being the value.
+    # When the class' structure mandates a Relationship, then the
+    # second object of the pair is a Link to the related resource,
+    # or an LinksEnumerator if it has many resources.
+    def structure_pairs(name) 
+      structure(name).map do |rel|
+        sym = nil
+        ret = case rel
+              when Symbol
+                sym = rel
+                send(sym)
+              when Relationship
+                sym = rel.sym
+                link_for_rel(rel)
+              end #case rel
+        [sym, ret]
+      end
+    end
+
+    def link_for_rel(rel)
+      if rel.one?
+        single_link_for_rel(rel)
+      elsif rel.many?
+        links_enumerator_for_rel(rel)
+      else
+        raise ArgumentError, "unkown relationship kinds #{rel.kinds}"
+      end #case rel.kind
+    end
+
+    # returns a lazy link loader for the relationship
+    # i.e., the evaluation of the sym method may be delayed
+    def single_link_for_rel(rel)
+      sym = rel.sym
+      Link.new(self, nil, :label => sym, :local => rel.alias?) do 
+        send(sym)
+      end
+    end
+
+    # returns a lazy link loader enumerator for the relationship
+    # it will yield a link
+    def links_enumerator_for_rel(rel)
+      sym = rel.sym
+      LinksEnumerator.new do |&blk|
+        send(sym).each do |i|
+          blk.call Link.new(self, i, :label => sym, :local => rel.alias?)
+        end
+      end
+    end
+
+    def match_params?(params, ident=:default, prefix='')
+      IdentifyingMatcher.new(params, prefix).match?(self, ident)
+    end
+
+    alias uuid object_id
+
+    def epitheting_path_part(resource, label)
+      File.join epithet(label).map{|sym| send(sym, resource).to_s}
+    end
+
+    def epithet_path_to(resource, label)
+      File.join label.to_s, epitheting_path_part(resource,label)
+    end
+
+    # Same as Resource.epithets
+    def epithets(label, prefix='')
+      epithet(label).map{|sym| ":#{prefix}#{sym}"}
+    end
+
+    def epithet_resource_match_params?(resource, params, label, prefix='')
+      EpithetMatcher.new(params, prefix).match?(self, resource, label)
+    end
+
+  end  # Resource
+end # Welo

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: welo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 6
+  version: 0.0.6
+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
+- README
+- lib/welo.rb
+- lib/welo/core/resource.rb
+- lib/welo/core/relationship.rb
+- lib/welo/core/link.rb
+- lib/welo/core/matcher.rb
+- lib/welo/core/nesting.rb
+- lib/welo/core/perspective.rb
+- lib/welo/base/resource.rb
+has_rdoc: true
+homepage: http://github.com/crapooze/welo
+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: welo
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A light resource model for Ruby
+test_files: []
+