praxis 0.0.1 → 0.9

data/lib/praxis/exceptions/invalid_configuration.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class InvalidConfiguration < Exception
+    end
+  end
+end

data/lib/praxis/exceptions/invalid_response.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class InvalidResponse < Exception
+    end
+  end
+end

data/lib/praxis/exceptions/invalid_trait.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class InvalidTrait < Exception
+    end
+  end
+end

data/lib/praxis/exceptions/stage_not_found.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class StageNotFound < Exception
+    end
+  end
+end

data/lib/praxis/exceptions/validation.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class Validation < Exception
+    end
+  end
+end

data/lib/praxis/file_group.rb

@@ -0,0 +1,39 @@
+module Praxis
+
+  class FileGroup
+
+    attr_reader :groups, :base
+
+    def initialize(base, &block)
+      @groups = Hash.new
+      @base = base
+
+      if block_given?
+        self.instance_eval(&block)
+      end
+    end
+
+    def layout(&block)
+      self.instance_eval(&block)
+    end
+
+    def map(name, pattern, &block)
+      if block_given?
+        @groups[name] = FileGroup.new(base + pattern, &block)
+      else
+        @groups[name] ||= []
+        file_enum = base.find.to_a
+        files = file_enum.select do |file|
+          path = file.relative_path_from(base)
+          file.file? && path.fnmatch?(pattern, File::FNM_PATHNAME)
+        end
+        files.sort_by { |file| [file.to_s.split('/').size, file.to_s] }.each { |file| @groups[name] << file }
+      end
+    end
+
+    def [](*names)
+      names.inject(@groups) { |group, name| group[name] || [] }
+    end
+
+  end
+end

data/lib/praxis/links.rb

@@ -0,0 +1,110 @@
+module Praxis
+
+  # Container for links for a given type
+  class Links < Praxis::Blueprint
+
+    class DSLCompiler < Attributor::DSLCompiler
+      attr_reader :links
+      def initialize(target, dsl_compiler_options:{}, **options)
+        @links = dsl_compiler_options[:links]
+
+        super
+      end
+
+      def link(name, type=nil, using: name, **opts, &block)
+        links[name] = using
+        attribute(name, type, **opts, &block)
+      end
+    end
+
+    class << self
+      attr_reader :links
+    end
+
+    def self.for(reference)
+      if defined?(reference::Links)
+        return reference::Links
+      end
+
+      klass = Class.new(self) do
+        @reference = reference
+        @links = Hash.new
+      end
+
+      reference.const_set :Links, klass
+    end
+
+    def self.construct(constructor_block, options)
+      options[:reference] = @reference
+      options[:dsl_compiler_options] = {links: self.links}
+
+      self.attributes(options, &constructor_block)
+      self
+    end
+
+    def self._finalize!
+      super
+      if @attribute
+        self.define_default_view
+        self.fixup_reference_struct_methods
+      end
+    end
+
+    def self.define_blueprint_reader!(name)
+      # it's faster to use define_method in this case than module_eval
+      # because we save the attribute lookup on every access.
+      attribute = self.attributes[name]
+      using = self.links.fetch(name) do
+        raise Exceptions::InvalidConfiguration.new("Cannot define attribute for #{name.inspect}")
+      end
+
+      define_method(name) do
+        value = @object.send(using)
+        return value if value.nil? || value.kind_of?(attribute.type)
+        attribute.type.new(value)
+      end
+
+      # do whatever crazy aliasing we need to here....
+      unless name == using
+        @attribute.type.instance_eval do
+          define_method(using) do
+            self.send(name)
+          end
+        end
+
+        @reference.attribute.type.instance_eval do
+          define_method(using) do
+            self.send(name)
+          end
+        end
+      end
+
+    end
+
+    def self.define_default_view
+      return unless view(:default).nil?
+
+      view(:default) {}
+      self.attributes.each do |name, attribute|
+        view(:default).attribute(name, view: :link)
+      end
+    end
+
+    # Define methods on the inner Struct class for
+    # links that do not have corresponding top-level attributes.
+    # This is primarily necessary only for example generation.
+    def self.fixup_reference_struct_methods
+      self.links.each do |name, using|
+        next if @reference.attribute.attributes.has_key?(name)
+        @reference.attribute.type.instance_eval do
+          define_method(using) do
+            return nil unless attributes[:links]
+            attributes[:links].send(name)
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/praxis/media_type.rb

@@ -0,0 +1,40 @@
+module Praxis
+  class MediaType < Praxis::Blueprint
+
+    class DSLCompiler < Attributor::DSLCompiler
+      def links(&block)
+        attribute :links, Praxis::Links.for(options[:reference]), dsl_compiler: Links::DSLCompiler, &block
+      end
+    end
+
+    def self.description(text=nil)
+      @description = text if text
+      @description
+    end
+
+    def self.identifier(identifier=nil)
+      return @identifier unless identifier
+      # TODO: parse the string and extract things like collection , and format type?...
+      @identifier = identifier
+    end
+
+    def self.describe(shallow = false)
+      hash = super
+      unless shallow
+        hash.merge!(identifier: @identifier, description: @description)
+      end
+      hash
+    end
+
+    def self.attributes(opts={}, &block)
+      super(opts.merge(dsl_compiler: MediaType::DSLCompiler), &block)
+    end
+
+    def links
+      self.class::Links.new(@object)
+    end
+
+
+  end
+
+end

data/lib/praxis/media_type_collection.rb

@@ -0,0 +1,120 @@
+module Praxis
+
+  module StructCollection
+    def self.included(klass)
+      klass.instance_eval do
+        include(Enumerable)
+      end
+    end
+
+    def _members=(members)
+      @members = members
+    end
+
+    def _members
+      @members || []
+    end
+
+    def each
+      _members.each { |member| yield(member) }
+    end
+  end
+
+  class MediaTypeCollection < MediaType
+    include Enumerable
+
+    def self._finalize!
+      super
+
+      if const_defined?(:Struct, false)
+        self::Struct.instance_eval do
+          include StructCollection
+        end
+      end
+
+    end
+
+    def self.member_type(type=nil)
+      return @media_type unless type
+      raise ArgumentError, "invalid type: #{type.name}" unless type < MediaType
+
+      @member_type = type
+    end
+
+    def self.example(context=nil, options: {})
+      result = super
+
+      context = case context
+      when nil
+        ["#{self.name}-#{values.object_id.to_s}"]
+      when ::String
+        [context]
+      else
+        context
+      end
+
+      members = []
+      size = rand(3) + 1
+
+
+      size.times do |i|
+        subcontext = context + ["at(#{i})"]
+        members << @member_type.example(subcontext)
+      end
+
+      
+      result.object._members = members
+      result
+    end
+
+    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
+      if value.kind_of?(String)
+        value = JSON.parse(value)
+      end
+
+      case value
+      when nil, self
+        value
+      when Hash
+        # Need to parse/deserialize first
+        self.new(self.attribute.load(value,context, **options))
+      when Array
+        object = self.attribute.load({})
+        object._members = value.collect { |subvalue| @member_type.load(subvalue) }
+        self.new(object)
+      else
+        # Just wrap whatever value
+        self.new(value)
+      end
+    end
+
+
+    def render(view_name=:default, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      if (view = self.class.views[view_name])
+        # we have the view ourselves, use it with our atrributes
+        super
+      else
+        # render each member with the view
+        @object.collect.with_index do |member, i| 
+          subcontext = context + ["at(#{i})"]
+          member.render(view_name, context: subcontext)
+        end
+      end
+    end
+
+
+    def each
+      @object.each { |member| yield(member) }
+    end
+
+
+    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
+      errors = super
+
+      @object.each_with_object(errors) do |member, errors|
+        errors.push(*member.validate(context))
+      end
+    end
+
+  end
+end

data/lib/praxis/multipart/parser.rb

@@ -0,0 +1,213 @@
+require 'rack/utils'
+
+# stolen from Rack::Multipart::Parser
+
+module Praxis
+  class MultipartParser
+    EOL = "\r\n"
+    MULTIPART_BOUNDARY = "AaB03x"
+    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
+    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
+    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
+    DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})/
+    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
+    BROKEN_QUOTED = /^#{CONDISP}.*;\sfilename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i
+    BROKEN_UNQUOTED = /^#{CONDISP}.*;\sfilename=(#{TOKEN})/i
+    MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni
+    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^\";]*)"?/ni
+    MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni
+
+    BUFSIZE = 16384
+
+    def self.parse(headers,body)
+      self.new(headers,body).parse
+    end
+
+    def initialize(headers, body)
+      @headers = headers
+      @io = StringIO.new
+      Array(body).each do |chunk|
+        @io << chunk
+      end
+      @io.rewind
+      @parts = Hash.new
+    end
+
+    def parse
+      return nil unless setup_parse
+
+      @preamble = fast_forward_to_first_boundary
+
+      loop do
+        head, filename, content_type, name, body =
+          get_current_head_and_filename_and_content_type_and_name_and_body
+
+        # Save the rest.
+        if i = @buf.index(rx)
+          body << @buf.slice!(0, i)
+          @buf.slice!(0, @boundary_size+2)
+
+          @content_length = -1  if $1 == "--"
+        end
+
+        filename, data = get_data(filename, body, content_type, name, head)
+
+        parsed_headers = head.split(EOL).each_with_object(Hash.new) do |line, hash|
+          match = /(?<k>[^:]+): (?<v>.*)/.match(line)
+          k = match[:k]
+          v = match[:v]
+          hash[k] = v
+        end
+
+        @parts[name] = MultipartPart.new(data, parsed_headers, filename: filename)
+
+        # break if we're at the end of a buffer, but not if it is the end of a field
+        break if (@buf.empty? && $1 != EOL) || @content_length == -1
+      end
+
+      @io.rewind
+
+      [@preamble, @parts]
+    end
+
+    private
+    def setup_parse
+      return false unless @headers['Content-Type'] =~ MULTIPART
+
+      @boundary = "--#{$1}"
+
+      @buf = ""
+
+      @params = Rack::Utils::KeySpaceConstrainedParams.new
+
+      #@io = @env['rack.input']
+      #@io.rewind
+
+      @boundary_size = Rack::Utils.bytesize(@boundary) + EOL.size
+
+      if @content_length = @headers['Content-Length']
+        @content_length = @content_length.to_i
+        @content_length -= @boundary_size
+      end
+      true
+    end
+
+    def full_boundary
+      @boundary + EOL
+    end
+
+    def rx
+      @rx ||= /(?:#{EOL})?#{Regexp.quote(@boundary)}(#{EOL}|--)/n
+    end
+
+    def fast_forward_to_first_boundary
+      preamble = ''
+      loop do
+        content = @io.read(BUFSIZE)
+        raise EOFError, "bad content body" unless content
+        @buf << content
+
+        while @buf.gsub!(/\A([^\n]*\n)/, '')
+          read_buffer = $1
+          if read_buffer == full_boundary
+            return preamble.gsub!(/\r\n$/,'')
+          else
+            preamble << read_buffer
+          end
+        end
+
+        raise EOFError, "bad content body" if Rack::Utils.bytesize(@buf) >= BUFSIZE
+      end
+    end
+
+    def get_current_head_and_filename_and_content_type_and_name_and_body
+      head = nil
+      body = ''
+      filename = content_type = name = nil
+      content = nil
+
+      until head && @buf =~ rx
+        if !head && i = @buf.index(EOL+EOL)
+          head = @buf.slice!(0, i+2) # First \r\n
+
+          @buf.slice!(0, 2)          # Second \r\n
+
+          content_type = head[MULTIPART_CONTENT_TYPE, 1]
+          name = head[MULTIPART_CONTENT_DISPOSITION, 1] || head[MULTIPART_CONTENT_ID, 1]
+          name.strip!
+
+          filename = get_filename(head)
+
+          if filename
+            body = Tempfile.new("RackMultipart")
+            body.binmode  if body.respond_to?(:binmode)
+          end
+
+          next
+        end
+
+        # Save the read body part.
+        if head && (@boundary_size+4 < @buf.size)
+          body << @buf.slice!(0, @buf.size - (@boundary_size+4))
+        end
+
+        content = @io.read(@content_length && BUFSIZE >= @content_length ? @content_length : BUFSIZE)
+        raise EOFError, "bad content body"  if content.nil? || content.empty?
+
+        @buf << content
+        @content_length -= content.size if @content_length
+      end
+
+      [head, filename, content_type, name, body]
+    end
+
+    def get_filename(head)
+      filename = nil
+      if head =~ RFC2183
+        filename = Hash[head.scan(DISPPARM)]['filename']
+        filename = $1 if filename and filename =~ /^"(.*)"$/
+      elsif head =~ BROKEN_QUOTED
+        filename = $1
+      elsif head =~ BROKEN_UNQUOTED
+        filename = $1
+      end
+
+      if filename && filename.scan(/%.?.?/).all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
+        filename = Rack::Utils.unescape(filename)
+      end
+      if filename && filename !~ /\\[^\\"]/
+        filename = filename.gsub(/\\(.)/, '\1')
+      end
+      filename
+    end
+
+    def get_data(filename, body, content_type, name, head)
+      data = nil
+      if filename == ""
+        # filename is blank which means no file has been selected
+        return data
+      elsif filename
+        body.rewind
+        
+        # Take the basename of the upload's original filename.
+        # This handles the full Windows paths given by Internet Explorer
+        # (and perhaps other broken user agents) without affecting
+        # those which give the lone filename.
+        filename = filename.split(/[\/\\]/).last
+
+        data = {:filename => filename, :type => content_type,
+                :name => name, :tempfile => body, :head => head}
+      elsif !filename && content_type && body.is_a?(IO)
+        body.rewind
+
+        # Generic multipart cases, not coming from a form
+        data = {:type => content_type,
+                :name => name, :tempfile => body, :head => head}
+      else
+        data = body
+      end
+
+      [filename, data]
+    end
+  end
+end

data/lib/praxis/multipart/part.rb

@@ -0,0 +1,26 @@
+module Praxis
+  class MultipartPart
+
+    attr_accessor :body
+    attr_accessor :headers
+    attr_accessor :filename
+    
+    def initialize(body, headers={}, filename: nil)
+      @body = body
+      @headers = headers
+      @filename = filename
+    end
+
+    def status
+      @headers['Status'].to_i
+    end
+
+    def encode!
+      case @body
+      when Hash, Array
+        @body = JSON.pretty_generate(@body)
+      end
+    end
+
+  end
+end

data/lib/praxis/plugin.rb

@@ -0,0 +1,30 @@
+module Praxis
+
+  # one instance is created per use.
+  class Plugin
+
+    attr_reader :application, :block
+
+    def initialize(application, &block)
+      @application = application
+      @block = block
+    end
+
+    def config
+      @application.config
+    end
+
+    def setup!
+    end
+
+    def after(stage,&block)
+      application.bootloader.after(stage,&block)
+    end
+
+    def before(stage,&block)
+      application.bootloader.before(stage,&block)
+    end
+
+
+  end
+end