majoun 0.0.1

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 50.5

data/lib/cookie.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'time'
+require 'base64'
+
+require 'concord'
+require 'adamantium'
+require 'abstract_type'
+
+# Models an HTTP Cookie
+class Cookie
+
+  # An empty frozen array
+  EMPTY_ARRAY = [].freeze
+
+  # An empty frozen hash
+  EMPTY_HASH = {}.freeze
+
+  # An empty frozen string
+  EMPTY_STRING = ''.freeze
+
+  # Separates the cookie name from its value
+  NAME_VALUE_SEPARATOR = '='.freeze
+
+  # Separates cookies
+  COOKIE_SEPARATOR = '; '.freeze
+
+  # Separates ruby class names in a FQN
+  DOUBLE_COLON = '::'.freeze
+
+  # Helper for cookie deletion
+  class Empty < self
+    def initialize(name)
+      super(name, nil)
+    end
+  end
+
+  # Namespace for cookie encoders
+  module Encoder
+    Base64 = ->(string) { ::Base64.urlsafe_encode64(string) }
+  end
+
+  # Namespace for cookie decoders
+  module Decoder
+    Base64 = ->(string) { ::Base64.urlsafe_decode64(string) }
+  end
+
+  # Cookie error base class
+  Error = Class.new(StandardError)
+
+  include Concord::Public.new(:name, :value)
+  include Adamantium::Flat
+
+  def self.coerce(string)
+    new(*string.split(NAME_VALUE_SEPARATOR, 2))
+  end
+
+  def encode(encoder = Encoder::Base64)
+    new(encoder.call(value))
+  end
+
+  def decode(decoder = Decoder::Base64)
+    new(decoder.call(value))
+  end
+
+  def encrypt(box)
+    new(box.encrypt(value))
+  end
+
+  def decrypt(box)
+    new(box.decrypt(value))
+  end
+
+  def to_s
+    "#{name}=#{value}"
+  end
+  memoize :to_s
+
+  private
+
+  def new(new_value)
+    self.class.new(name, new_value)
+  end
+
+end # class Cookie
+
+require 'cookie/header'
+require 'cookie/header/attribute'
+require 'cookie/registry'

data/lib/cookie/header.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+class Cookie
+
+  # Models a transient, new cookie on the server that can be serialized
+  # into an HTTP 'Set-Cookie' header
+  class Header
+
+    include Equalizer.new(:cookie, :attributes)
+    include Adamantium::Flat
+
+    attr_reader :cookie
+    protected   :cookie
+
+    attr_reader :attributes
+    protected   :attributes
+
+    def self.build(name, value, attributes)
+      new(Cookie.new(name, value), attributes)
+    end
+
+    def initialize(cookie, attributes = Attribute::Set::EMPTY)
+      @cookie, @attributes = cookie, attributes
+    end
+
+    def with_domain(domain)
+      with_attribute(Attribute::Domain.new(domain))
+    end
+
+    def with_path(path)
+      with_attribute(Attribute::Path.new(path))
+    end
+
+    def with_max_age(seconds)
+      with_attribute(Attribute::MaxAge.new(seconds))
+    end
+
+    def with_expires(time)
+      with_attribute(Attribute::Expires.new(time))
+    end
+
+    def secure
+      with_attribute(Attribute::Secure.instance)
+    end
+
+    def http_only
+      with_attribute(Attribute::HttpOnly.instance)
+    end
+
+    def delete
+      new(Empty.new(cookie.name), attributes.merge(Attribute::Expired))
+    end
+
+    def to_s
+      "#{cookie}#{attributes}"
+    end
+    memoize :to_s
+
+    private
+
+    def with_attribute(attribute)
+      new(cookie, attributes.merge(attribute))
+    end
+
+    def new(cookie, attributes)
+      self.class.new(cookie, attributes)
+    end
+
+  end # class Header
+end # class Cookie

data/lib/cookie/header/attribute.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+class Cookie
+  class Header
+
+    # Baseclass for cookie attributes
+    class Attribute
+
+      include Concord::Public.new(:name)
+      include Adamantium
+
+      REGISTRY = {}
+
+      def self.coerce(name, value)
+        REGISTRY.fetch(name.to_sym).build(value)
+      end
+
+      def self.register_as(name)
+        REGISTRY[name.to_sym] = self
+      end
+
+      def self.attribute_name
+        name.split(DOUBLE_COLON).last
+      end
+
+      def to_s
+        name
+      end
+
+      # Models a set of attributes used within a {Serializable} cookie
+      class Set
+
+        include Concord.new(:attributes)
+        include Enumerable
+        include Adamantium
+
+        def self.coerce(attributes)
+          new(attributes.each_with_object({}) { |(name, value), hash|
+            attribute = Attribute.coerce(name, value)
+            hash[attribute.name] = attribute if attribute
+          })
+        end
+
+        def each(&block)
+          return to_enum unless block
+          attributes.each_value(&block)
+          self
+        end
+
+        def merge(attribute)
+          Set.new(attributes.merge(attribute.name => attribute))
+        end
+
+        def to_s
+          "#{COOKIE_SEPARATOR}#{map(&:to_s).join(COOKIE_SEPARATOR)}"
+        end
+        memoize :to_s
+
+        # An empty {Set} to be serialized to {EMPTY_STRING}
+        class Empty < self
+
+          def initialize
+            super(EMPTY_HASH)
+          end
+
+          def to_s
+            EMPTY_STRING
+          end
+
+        end # class Empty
+
+        EMPTY = Empty.new
+
+      end # class Set
+
+      # Abstract baseclass for attributes that have no value
+      #
+      # @abstract
+      class Unary < self
+
+        include AbstractType
+
+        CACHE = {}
+
+        def self.build(value)
+          value ? instance : nil
+        end
+
+        def self.instance
+          CACHE.fetch(attribute_name) {
+            CACHE[attribute_name] = new(attribute_name)
+          }
+        end
+
+      end
+
+      # Abstract baseclass for attributes that consist of a name-value
+      # pair
+      #
+      # @abstract
+      class Binary < self
+
+        include AbstractType
+        include Equalizer.new(:name, :value)
+
+        attr_reader :value
+        protected   :value
+
+        def self.build(value)
+          new(value)
+        end
+
+        def initialize(value)
+          super(self.class.attribute_name)
+          @value = value
+        end
+
+        def to_s
+          "#{name}=#{serialized_value}"
+        end
+        memoize :to_s
+
+        private
+
+        def serialized_value
+          value
+        end
+
+      end # class Binary
+
+      # The Domain attribute
+      class Domain < Binary
+        register_as :domain
+      end
+
+      # The Path attribute
+      class Path < Binary
+        register_as :path
+      end
+
+      # The Max-Age attribute
+      class MaxAge < Binary
+        register_as :max_age
+      end
+
+      # The Expires attribute
+      class Expires < Binary
+        register_as :expires
+
+        private
+
+        def serialized_value
+          super.dup.gmtime.rfc2822
+        end
+      end
+
+      # The Secure attribute
+      class Secure < Unary
+        register_as :secure
+      end
+
+      # The HttpOnly attribute
+      class HttpOnly < Unary
+        register_as :http_only
+      end
+
+      # Already expired {Expires} attribute useful for cookie deletion
+      Expired = Expires.new(Time.at(0))
+
+    end # class Attribute
+  end # class Header
+end # class Cookie

data/lib/cookie/registry.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+class Cookie
+
+  # Models a registry of {Cookie} instances
+  class Registry
+
+    include Enumerable
+    include Equalizer.new(:entries)
+    include Adamantium::Flat
+
+    # Message for {UnknownCookieError}
+    UNKNOWN_COOKIE_MSG = 'No cookie named %s is registered'.freeze
+
+    # Raised when trying to {#fetch} an unknown {Cookie}
+    UnknownCookieError = Class.new(Cookie::Error)
+
+    def self.coerce(header)
+      new(cookie_hash(header))
+    end
+
+    def self.cookie_hash(header)
+      header.split(COOKIE_SEPARATOR).each_with_object({}) { |string, hash|
+        cookie = Cookie.coerce(string)
+        hash[cookie.name] = cookie
+      }
+    end
+
+    private_class_method :cookie_hash
+
+    attr_reader :entries
+    protected   :entries
+
+    def initialize(entries = EMPTY_HASH)
+      @entries = entries
+    end
+
+    def each(&block)
+      return to_enum unless block
+      entries.each(&block)
+      self
+    end
+
+    def fetch(name)
+      get(name) or raise UnknownCookieError, UNKNOWN_COOKIE_MSG % name.inspect
+    end
+
+    def get(name)
+      @entries[name]
+    end
+
+  end # class Registry
+end # class Cookie

data/lib/cookie/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+class Cookie
+
+  # Gem version
+  VERSION = '0.0.1'.freeze
+
+end

data/majoun.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/cookie/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "majoun"
+  gem.version     = Cookie::VERSION.dup
+  gem.authors     = [ "Martin Gamsjaeger (snusnu)" ]
+  gem.email       = [ "gamsnjaga@gmail.com" ]
+  gem.description = "An HTTP cookie implemented in ruby"
+  gem.summary     = "Support for sending and receiving HTTP cookies on ruby servers"
+  gem.homepage    = "https://github.com/snusnu/cookie"
+
+  gem.require_paths    = [ "lib" ]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.md TODO.md]
+  gem.license          = 'MIT'
+
+  gem.add_dependency 'adamantium',    '~> 0.2.0'
+  gem.add_dependency 'abstract_type', '~> 0.0.7'
+  gem.add_dependency 'concord',       '~> 0.1.4'
+
+  gem.add_development_dependency 'bundler', '~> 1.6.1'
+end

data/spec/integration/public_api_spec.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Spec
+  class CryptoBox
+    def encrypt(string)
+      string
+    end
+
+    def decrypt(string)
+      string
+    end
+  end
+
+  module Encoder
+    Noop = ->(string) { string }
+  end
+
+  module Decoder
+    Noop = ->(string) { string }
+  end
+end
+
+shared_context 'integration specs' do
+  let(:cookie) { Cookie.new(name, value) }
+  let(:name)   { 'SID' }
+  let(:value)  { '{"id": 11}' } # triggers padding char '=' when base64 encoded
+end
+
+describe Cookie do
+
+  include_context 'integration specs'
+
+  let(:encoder) { Spec::Encoder::Noop }
+  let(:decoder) { Spec::Decoder::Noop }
+  let(:box)     { Spec::CryptoBox.new }
+
+  it 'supports coercion from string to a Cookie instance' do
+    c = cookie
+    expect(Cookie.coerce(c.to_s)).to eql(cookie)
+
+    c = cookie.encode
+    expect(Cookie.coerce(c.to_s)).to eql(cookie.encode)
+
+    c = c.decode
+    expect(Cookie.coerce(c.to_s)).to eql(cookie)
+  end
+
+  it 'supports #name and #value' do
+    expect(cookie.name).to be(name)
+    expect(cookie.value).to be(value)
+  end
+
+  it 'supports #to_s' do
+    expect(cookie.to_s).to eql("#{cookie.name}=#{cookie.value}")
+  end
+
+  context 'encoding and decoding' do
+    it 'defaults to base64' do
+      encoded = cookie.encode
+      expect(encoded).to eql(Cookie.new(name, Base64.urlsafe_encode64(cookie.value)))
+
+      decoded = encoded.decode
+      expect(decoded).to eql(Cookie.new(name, Base64.urlsafe_decode64(encoded.value)))
+    end
+
+    it 'supports custom encoders and decoders' do
+      encoded = cookie.encode(encoder)
+      expect(encoded).to eql(Cookie.new(name, encoder.call(cookie.value)))
+
+      decoded = encoded.decode(decoder)
+      expect(decoded).to eql(Cookie.new(name, decoder.call(encoded.value)))
+    end
+  end
+
+  context 'encryption and decryption' do
+    it 'supports crypto boxes which provide #encrypt(msg) and #decrypt(msg)' do
+      encrypted = cookie.encrypt(box)
+      expect(encrypted).to eql(Cookie.new(name, box.encrypt(cookie.value)))
+
+      decrypted = encrypted.decrypt(box)
+      expect(decrypted).to eql(Cookie.new(name, box.decrypt(encrypted.value)))
+    end
+  end
+end
+
+describe Cookie::Header do
+
+  include_context 'integration specs'
+
+  let(:definition) { Cookie::Header.new(cookie) }
+
+  it 'supports all cookie attributes' do
+    d = definition
+    expect(d.to_s).to eql('SID={"id": 11}')
+
+    d = definition.with_domain('.foo.bar')
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar')
+
+    d = d.with_path('/foo')
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar; Path=/foo')
+
+    d = d.with_expires(Time.at(42))
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar; Path=/foo; Expires=Thu, 01 Jan 1970 00:00:42 -0000')
+
+    d = d.with_max_age(42)
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar; Path=/foo; Expires=Thu, 01 Jan 1970 00:00:42 -0000; MaxAge=42')
+
+    d = d.secure
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar; Path=/foo; Expires=Thu, 01 Jan 1970 00:00:42 -0000; MaxAge=42; Secure')
+
+    d = d.http_only
+    expect(d.to_s).to eql('SID={"id": 11}; Domain=.foo.bar; Path=/foo; Expires=Thu, 01 Jan 1970 00:00:42 -0000; MaxAge=42; Secure; HttpOnly')
+
+    d = definition.secure
+    expect(d.to_s).to eql('SID={"id": 11}; Secure')
+
+    d = d.http_only
+    expect(d.to_s).to eql('SID={"id": 11}; Secure; HttpOnly')
+
+    d = definition.http_only
+    expect(d.to_s).to eql('SID={"id": 11}; HttpOnly')
+
+    d = d.secure
+    expect(d.to_s).to eql('SID={"id": 11}; HttpOnly; Secure')
+  end
+
+  it 'overwrites previously defined attributes' do
+    d = definition.with_max_age(0).with_max_age(42)
+    expect(d.to_s).to eql('SID={"id": 11}; MaxAge=42')
+  end
+
+  it 'supports deleting cookies on the client' do
+    d = definition.delete
+    expect(d.to_s).to eql('SID=; Expires=Thu, 01 Jan 1970 00:00:00 -0000')
+
+    d = definition.with_domain('.foo.bar').with_path('/foo')
+    d = d.delete
+    expect(d.to_s).to eql('SID=; Domain=.foo.bar; Path=/foo; Expires=Thu, 01 Jan 1970 00:00:00 -0000')
+  end
+end
+
+describe Cookie::Registry do
+
+  include_context 'integration specs'
+
+  let(:registry) { Cookie::Registry.coerce(header) }
+  let(:header)   { cookie.to_s }
+
+  it 'contains no entries after #initialize' do
+    expect(Cookie::Registry.new.count).to be(0)
+  end
+
+  it 'supports coercion from a Set-Cookie header' do
+    expect(registry.get(name)).to eql(cookie)
+  end
+
+  it 'supports #get(name)' do
+    expect(registry.get(name)).to eql(cookie)
+    expect(registry.get(:foo)).to be(nil)
+  end
+
+  it 'supports #fetch(name)' do
+    expect(registry.fetch(name)).to eql(cookie)
+    expect { registry.fetch(:foo) }.to raise_error(Cookie::Registry::UnknownCookieError)
+  end
+
+  it 'is an Enumerable' do
+    expect(registry).to be_kind_of(Enumerable)
+  end
+
+  context '#each' do
+    it 'returns self when a block is given' do
+      expect(registry.each { |_| }).to be(registry)
+    end
+
+    it 'returns an enumerator when no block is given' do
+      expect(registry.each).to be_instance_of(Enumerator)
+    end
+
+    it 'yields all cookies' do
+      expect { |block| registry.each(&block) }.to yield_successive_args([name, cookie])
+    end
+  end
+end