spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/bin/limit-upload

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-sudo ipfw pipe 1 config bw ${1}KByte/s
-sudo ipfw add 1 pipe 1 dst-port ${2}
-# sudo ipfw add 1 pipe 1 dst-port 9000

data/bin/unlimit-upload

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-sudo ipfw delete 1

data/lib/spontaneous/asset/file.rb

@@ -1,25 +0,0 @@
-require 'pathname'
-
-module Spontaneous::Asset
-  class File
-    def initialize(source, relative_path)
-      @source, @relative_path = source, relative_path
-    end
-
-    def load_path
-      [name, extensions.first].join(".")
-    end
-
-    def basename
-      @basename ||= ::File.basename(@relative_path)
-    end
-
-    def name
-      basename.split(".").first
-    end
-
-    def extensions
-      @extensions ||= basename.split(".")[1..-1]
-    end
-  end
-end

data/lib/spontaneous/asset/source.rb

@@ -1,28 +0,0 @@
-require 'pathname'
-
-module Spontaneous::Asset
-  class Source
-    def initialize(source_dir)
-      @source_dir = ::File.expand_path(source_dir)
-    end
-
-    def source_path
-      @source_path ||= Pathname.new(@source_dir)
-    end
-
-    def source_files
-      source_paths.map(&:to_s)
-    end
-
-    def source_paths
-      @source_files ||= find_source_paths
-    end
-
-    def find_source_paths
-      absolute_paths = Dir[@source_dir / "**/*.*"].map { |path| Pathname.new(path) }
-      source_path = self.source_path
-      absolute_paths.map { |path| path.relative_path_from(source_path) }
-    end
-  end
-end
-

data/lib/spontaneous/image_size.rb

@@ -1,123 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module ImageSize
-    def self.read(file)
-      reader = ImageReader.new(file)
-      reader.size
-    end
-
-    class ImageReader
-
-      def initialize(file)
-        if file.kind_of? IO
-          read_size(file)
-        else
-          File.open(file, 'rb') { |io| read_size(io) }
-        end
-      end
-
-      def read_size(file)
-        klass = image_type(file)
-        @image = klass.new(file)
-      end
-
-      def image_type(file)
-        return Formats::EMPTY if file.size == 0
-        img_top = file.read(16)
-        bytes = img_top.unpack("C*")
-        file.seek(0,0)
-        if img_top =~ /^GIF8[7,9]a/
-          Formats::GIF
-        elsif bytes[0, 8] == [137, 80, 78, 71, 13, 10, 26, 10]
-          Formats::PNG
-        elsif bytes[0, 2] == [255, 216]
-          Formats::JPEG
-        else
-          Formats::OTHER
-        end
-      end
-
-      def size
-        @image.size
-      end
-
-      module Formats
-        class Abstract
-          def initialize(file)
-            @file = file
-            def @file.read_o(length = 1, offset = nil)
-              self.seek(offset, 0) if offset
-              ret = self.read(length)
-              raise "cannot read!!" unless ret
-              ret
-            end
-            # read size straight away so that if file is closed we don't raise an error
-            @size = read_size
-          end
-          def size
-            @size
-          end
-
-          def read_size
-            [0,0]
-          end
-        end
-
-        class EMPTY
-          def initialize(file)
-          end
-          def size
-            [0, 0]
-          end
-        end
-        class GIF < Abstract
-          def read_size
-            @file.read_o(6)
-            @file.read_o(4).unpack('vv')
-          end
-        end
-
-        class JPEG < Abstract
-          JPEGCodeCheck = [
-            "\xc0", "\xc1", "\xc2", "\xc3",
-            "\xc5", "\xc6", "\xc7",
-            "\xc9", "\xca", "\xcb",
-            "\xcd", "\xce", "\xcf",
-          ].map { |c| c.unpack('C').first }
-
-          def read_size
-            c_marker = 255 # Section marker.
-
-            @file.read_o(2)
-            while(true)
-              marker, code, length = @file.read_o(4).unpack('CCn')
-              raise "JPEG marker not found!" if marker != c_marker
-
-              if JPEGCodeCheck.include?(code)
-                height, width = @file.read_o(5).unpack('xnn')
-                return([width, height])
-              end
-              @file.read_o(length - 2)
-            end
-          end
-        end
-        class PNG < Abstract
-          def read_size
-            @file.read_o(12)
-            raise "This file is not PNG." unless @file.read_o(4) == "IHDR"
-            @file.read_o(8).unpack('NN')
-          end
-        end
-
-
-
-        class OTHER < Abstract
-          def read_size
-            [0,0]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spontaneous/output/assets/compression.rb

@@ -1,58 +0,0 @@
-require 'shine'
-require 'sass'
-
-module Spontaneous
-  module Output
-    module Assets
-      module Compression
-        extend self
-
-        def compress_js(filelist, options={})
-          shine_compress_files(filelist, :js, options)
-        end
-
-        def compress_js_string(js, options={})
-          shine_compress_string(js, :js, options)
-        end
-
-        def compress_css(filelist, options={})
-          # compress_files(filelist, :css, options)
-          opts = {
-            :load_paths => [Spontaneous.css_dir],
-            # :filename => sass_template,
-            :cache => false,
-            :style => :compressed
-          }.merge(options)
-          css = filelist.map do |path|
-            Sass::Engine.for_file(path, opts).render
-          end.join("\n")
-          hash = digest(css)
-          [css, hash]
-        end
-
-        def shine_compress_string(string, format, options = {})
-          compressed = Shine::compress_string(string, format, options).force_encoding("UTF-8")
-          hash = digest(compressed)
-          [compressed, hash]
-        end
-
-        def shine_compress_files(filelist, format, options = {})
-          original_size = filesize(filelist)
-          compressed = Shine::compress_files(filelist, format, options).force_encoding("UTF-8")
-          logger.info("Compressed #{filelist.length} files. Original size #{original_size}, compressed size #{compressed.length}, ratio #{(100*compressed.length.to_f/original_size.to_f).round}%")
-          hash = digest(compressed)
-          [compressed, hash]
-        end
-
-        def digest(str)
-          hash = Digest::SHA1.new.update(str).hexdigest
-        end
-
-
-        def filesize(paths)
-          paths.compact.inject(0) { |sum, path| sum += File.size(path) }
-        end
-      end
-    end
-  end
-end

data/lib/spontaneous/output/assets.rb

@@ -1,32 +0,0 @@
-module Spontaneous
-  module Output
-    module Assets
-      extend self
-
-      def compress_js(file_paths, options={})
-        Compression.compress_js(file_paths, options)
-      end
-
-      def url(file = nil)
-        Spontaneous::Output.asset_url(file)
-      end
-
-      def path_for(revision, path = nil)
-        File.join [Spontaneous::Output.asset_path(revision), path].compact
-      end
-
-      def find_file(*relative_paths)
-        relative_paths.flatten!
-        Spontaneous.instance.paths.expanded(:public).each do |root|
-          relative_paths.each do |relative_path|
-            path = root / relative_path
-            return path if ::File.exist?(path)
-          end
-        end
-        nil
-      end
-
-      autoload :Compression, "spontaneous/output/assets/compression"
-    end
-  end
-end

data/lib/spontaneous/rack/around_back.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Rack
-    class AroundBack
-      def initialize(app)
-        @app = app
-      end
-
-
-      def call(env)
-        response = nil
-        Spontaneous::Content.scope(nil, false) do
-          response = @app.call(env)
-        end
-        response
-      end
-    end
-  end
-end

data/lib/spontaneous/rack/around_front.rb

@@ -1,27 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Rack
-    POWERED_BY = {
-      "X-Powered-By" => "Spontaneous CMS v#{Spontaneous::VERSION}"
-    }
-
-    class AroundFront
-      def initialize(app)
-        @app = app
-        @renderer = Spontaneous::Output.published_renderer
-      end
-
-      def call(env)
-        status = headers = body = nil
-        env[Rack::RENDERER] = @renderer
-        Spontaneous::Content.with_published do
-          status, headers, body = @app.call(env)
-        end
-        [status, headers.merge(POWERED_BY), body]
-      end
-    end
-
-  end
-end
-

data/lib/spontaneous/rack/around_preview.rb

@@ -1,22 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Rack
-    class AroundPreview
-      def initialize(app)
-        @app = app
-        @renderer = Spontaneous::Output.preview_renderer
-        Spontaneous::Output.renderer = @renderer
-      end
-
-      def call(env)
-        env[Rack::RENDERER] = @renderer
-        response = nil
-        Spontaneous::Content.scope(nil, true) do
-          response = @app.call(env)
-        end
-        response
-      end
-    end
-  end
-end

data/lib/spontaneous/rack/assets.rb

@@ -1,126 +0,0 @@
-# encoding: UTF-8
-
-require 'shine'
-require 'sass'
-
-module Spontaneous
-  module Rack
-    module Assets
-
-      # module Bundling
-      #   extend self
-
-      #   def compress_js(filelist, options={})
-      #     shine_compress_files(filelist, :js, options)
-      #   end
-
-      #   def compress_css(filelist, options={})
-      #     # compress_files(filelist, :css, options)
-      #     options = {
-      #       :load_paths => [Spontaneous.css_dir],
-      #       # :filename => sass_template,
-      #       :cache => false,
-      #       :style => :compressed
-      #     }
-      #     paths = paths(filelist)
-      #     css = paths.map do |path|
-      #       Sass::Engine.for_file(path, options).render
-      #     end.join("\\n")
-      #     hash = digest(css)
-      #     [css, hash]
-      #   end
-
-      #   def shine_compress_files(filelist, format, options = {})
-      #     paths = paths(filelist)
-      #     original_size = filesize(paths)
-      #     compressed = Shine::compress_files(paths, format, options)
-      #     logger.info("Compressed #{filelist.length} files. Original size #{original_size}, compressed size #{compressed.length}, ratio #{(100*compressed.length.to_f/original_size.to_f).round}%")
-      #     hash = digest(compressed)
-      #     [compressed, hash]
-      #   end
-
-      #   def digest(str)
-      #     hash = Digest::SHA1.new.update(str).hexdigest
-      #   end
-
-      #   def paths(filelist)
-      #     filelist.map { |file| filepath(file) }.tap do |paths|
-      #       logger.info("Bundling #{paths.length} files")
-      #     end
-      #   end
-
-      #   def filepath(file)
-      #     File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
-      #   end
-
-      #   def filesize(paths)
-      #     paths.inject(0) { |sum, path| sum += File.size(path) }
-      #   end
-      # end
-      module JavaScript
-        extend Spontaneous::Output::Assets::Compression
-
-        def self.filetype
-          "js"
-        end
-
-        def self.extension
-          "js"
-        end
-
-        def self.compress(filelist)
-          compress_js(paths(filelist))
-        end
-
-        def paths(filelist)
-          filelist.map { |file| filepath(file) }.tap do |paths|
-            logger.info("Bundling #{paths.length} files")
-          end
-        end
-
-        def filepath(file)
-          File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
-        end
-
-        # TODO: remove these
-        JQUERY = %w(vendor/jquery)
-        COMPATIBILITY = []#%w(compatibility)
-        REQUIRE = %w(require)
-        LOGIN_JS = %w(login)
-        EDITING_JS = %w(spontaneous)
-      end
-
-      module CSS
-        extend Spontaneous::Output::Assets::Compression
-
-        def self.filetype
-          "css"
-        end
-        def self.extension
-          "scss"
-        end
-
-        def self.compress(filelist)
-          compress_css(paths(filelist))
-        end
-
-
-        def paths(filelist)
-          filelist.map { |file| filepath(file) }.tap do |paths|
-            logger.info("Bundling #{paths.length} files")
-          end
-        end
-
-        def filepath(file)
-          File.join(Spontaneous.application_dir, filetype, "#{file}.#{extension}")
-        end
-
-        # TODO: remove these
-        LOGIN_CSS = %w(spontaneous) # login
-        EDITING_CSS = %w(spontaneous)
-        SCHEMA_MODIFICATION_CSS = %w(spontaneous) #schema_error
-      end
-
-    end # Assets
-  end # Rack
-end # Spontaneous

data/lib/spontaneous/rack/authentication.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-require 'rack'
-
-module Spontaneous::Rack
-  module Authentication
-
-    def requires_authentication!(options = {})
-      first_level_exceptions = (options[:except_all] || []).concat(["#{NAMESPACE}/login", "#{NAMESPACE}/reauthenticate"] )
-      second_level_exceptions = (options[:except_key] || [])
-      before {
-        unless first_level_exceptions.any? { |e| e === request.path }
-          ignore_key = second_level_exceptions.any? { |e| e === request.path }
-          valid_key = ignore_key || Spontaneous::Permissions::AccessKey.valid?(params[KEY_PARAM], user)
-          show_login_page( :login => '' ) unless (user and valid_key)
-        end
-      }
-    end
-  end
-end

data/lib/spontaneous/rack/cookie_authentication.rb

@@ -1,38 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Rack
-    class CookieAuthentication
-      def initialize(app)
-        @app = app
-      end
-
-      def access_key(env)
-        if login = Site.config.auto_login
-          user = Spontaneous::Permissions::User.login(login)
-          if user.access_keys.empty?
-            user.generate_access_key(env["REMOTE_ADDR"])
-          else
-            user.access_keys.first
-          end
-        else
-          request = ::Rack::Request.new(env)
-          api_key = request.cookies[Spontaneous::Rack::AUTH_COOKIE]
-          if api_key && key = Spontaneous::Permissions::AccessKey.authenticate(api_key, env["REMOTE_ADDR"])
-            key
-          else
-            nil
-          end
-        end
-      end
-
-      def call(env)
-        response = nil
-        key = env[S::Rack::ACTIVE_KEY] = access_key(env)
-        user = env[S::Rack::ACTIVE_USER] = key.user if key
-        response = @app.call(env)
-        response
-      end
-    end
-  end
-end

data/lib/spontaneous/rack/helpers.rb

@@ -1,52 +0,0 @@
-# encoding: UTF-8
-
-require 'sprockets'
-
-module Spontaneous
-  module Rack
-    module Helpers
-      def json(response)
-        content_type 'application/json', :charset => 'utf-8'
-        response.serialise_http(user)
-      end
-
-      def application_assets
-        @application_assets_compiler ||= Spontaneous::Asset::AppCompiler.new(Spontaneous.gem_dir, Spontaneous.root)
-      end
-
-      def style_url(style)
-        asset_url(style, "css")
-      end
-
-      def script_url(script)
-        asset_url(script, "js")
-      end
-
-      def asset_url(file, type)
-        file = "#{file}.#{type}" unless file =~ /\.#{type}$/
-
-        if (compiled_asset = application_assets.manifest.assets[file])
-          return "#{NAMESPACE}/assets/#{compiled_asset}"
-        end
-        # TODO: use the sprockets environment to append a modification time to the non-compiled URL
-        "#{NAMESPACE}/#{type}/#{file}"
-      end
-
-      def script_list(scripts)
-        scripts.map do |script|
-          script = "#{script}.js" unless script =~ /\.js$/
-          src = script_url(script)
-          size = 0
-          if (asset = application_assets.manifest.files[File.basename(src)])
-            size = asset["size"]
-          else
-            src = "#{NAMESPACE}/js/#{script}"
-            path = Spontaneous.application_dir("/js/#{script}")
-            size = File.size(path)
-          end
-          [src, size]
-        end.to_json
-      end
-    end
-  end
-end

data/lib/spontaneous/rack/http.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous
-  module Rack
-    module HTTP
-      METHOD_GET = "GET".freeze
-      METHOD_POST = "POST".freeze
-      METHOD_HEAD = "HEAD".freeze
-      HTTP_CONTENT_LENGTH = "Content-Length".freeze
-      HTTP_EXPIRES = "Expires".freeze
-      HTTP_CACHE_CONTROL = "Cache-Control".freeze
-      HTTP_LAST_MODIFIED = "Last-Modified".freeze
-      HTTP_NO_CACHE = "max-age=0, must-revalidate, no-cache, no-store".freeze
-    end
-  end
-end
-

data/lib/spontaneous/rack/media.rb

@@ -1,30 +0,0 @@
-# encoding: UTF-8
-
-require 'rack'
-
-module Spontaneous::Rack
-  class XXX < ::Rack::File
-    include HTTP
-
-    TEN_YEARS = 10*365*24*3600
-    MAX_AGE =  "max-age=#{TEN_YEARS}, public".freeze
-
-    def initialize(file_root)
-      super(file_root, 'public')
-    end
-
-    def call(env)
-      status, headers, body = super
-      [status, caching_headers(headers), body]
-    end
-
-    # media is never over-written so we can make sure clients
-    # never make the same request twice
-    def caching_headers(headers)
-      headers.merge({
-        HTTP_CACHE_CONTROL => MAX_AGE,
-        HTTP_EXPIRES => (Time.now + TEN_YEARS).httpdate
-      })
-    end
-  end
-end

data/lib/spontaneous/rack/query_authentication.rb

@@ -1,35 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module Rack
-    # Rack middleware that only allows access if the access key passed in the request query
-    # matches that used in the cookie
-    #
-    # Depends on CookieAuthentication being in the chain *before* this app to set up the current user in the env
-    class QueryAuthentication
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        user = env[S::Rack::ACTIVE_USER]
-        if user.nil?
-          unauthorized!
-        else
-          request = ::Rack::Request.new(env)
-          key = request[S::Rack::KEY_PARAM]
-          if ::S::Permissions::AccessKey.valid?(key, user)
-            @app.call(env)
-          else
-            unauthorized!
-          end
-        end
-      end
-
-      def unauthorized!
-        [401, {}, "Unauthorized"]
-      end
-    end
-  end
-end
-