starry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b104249aac02869f4536ddd816a828005419c76b7dfd14222ba781599d9ffc94
+  data.tar.gz: a795783282e4123bc20a964e90c36cfa228d257b2fe8e25c0cb83970aa87d2df
+SHA512:
+  metadata.gz: 6502b2202ae627ebd6bdbb2a4590ff8c4fac70fcc8373a8d44d214617132dcab7e5a2e2ec7b3792503f4e3379f1d6ae489d80c545936d1c58ff3b438c23f62b2
+  data.tar.gz: 02ddf59cef3d6399c5deabf6c438b18685936727ed3cac0be5671cece355559d9620b246cb6fd1d757a0d7dbb2ba1af7a704c78325e8313945a08056df0d94b0

data/lib/starry/inner_list.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+
+class Starry::InnerList
+
+  attr_accessor :value, :parameters
+
+  include Enumerable
+  extend Forwardable
+  def_delegator :value, :each
+
+  def initialize(value = [], parameters = {})
+    @value = value
+    @parameters = parameters
+  end
+
+  def ==(other)
+    self.class == other.class && self.value == other.value && self.parameters == other.parameters
+  end
+
+  def to_s
+    members = self.map do |item|
+      Starry.serialize_item(item)
+    end
+    "(#{ members.join(' ') })#{ Starry.serialize_parameters(parameters) }"
+  end
+end

data/lib/starry/item.rb

@@ -0,0 +1,17 @@
+class Starry::Item
+
+  attr_accessor :value, :parameters
+
+  def initialize(value, parameters = {})
+    @value = value
+    @parameters = parameters
+  end
+
+  def ==(other)
+    self.class == other.class && self.value == other.value && self.parameters == other.parameters
+  end
+
+  def to_s
+    "#{ Starry.serialize_bare_item(value) }#{ Starry.serialize_parameters(parameters) }"
+  end
+end

data/lib/starry/parser.rb

@@ -0,0 +1,205 @@
+require 'base64'
+require 'forwardable'
+require 'strscan'
+
+class Starry::Parser
+
+  extend Forwardable
+
+  def initialize(input, symbolize_names: false)
+    @s = StringScanner.new(input)
+    @symbolize_names = symbolize_names
+  end
+
+  def parse(type)
+    consume_sp
+    output = (
+      case type
+      when :list
+        parse_list
+      when :dictionary
+        parse_dictionary
+      when :item
+        parse_item
+      else
+        raise ArgumentError
+      end
+    )
+    consume_sp
+    unless @s.eos?
+      parse_error(:eos)
+    end
+    output
+  end
+
+  def parse_list
+    output = []
+    until eos?
+      output << parse_item_or_inner_list
+      consume_ows
+      return output if eos?
+      expect(',')
+      consume_ows
+      parse_error if eos?
+    end
+    output
+  end
+
+  def parse_item_or_inner_list
+    if check('(')
+      parse_inner_list
+    else
+      parse_item
+    end
+  end
+
+  def parse_inner_list
+    output = []
+    expect('(')
+    until eos?
+      consume_sp
+      if scan(')')
+        parameters = parse_parameters
+        return Starry::InnerList.new(output, parameters)
+      end
+      output << parse_item
+      unless check(/[ )]/)
+        parse_error([' ', ')'])
+      end
+    end
+    parse_error(')')
+  end
+
+  def parse_dictionary
+    output = {}
+    until eos?
+      key = parse_key
+      if scan('=')
+        value = parse_item_or_inner_list
+      else
+        parameters = parse_parameters
+        value = Starry::Item.new(true, parameters)
+      end
+      output[key] = value
+      consume_ows
+      return output if eos?
+      expect(',')
+      consume_ows
+      parse_error if eos?
+    end
+    output
+  end
+
+  def parse_item
+    value = parse_bare_item
+    parameters = parse_parameters
+    Starry::Item.new(value, parameters)
+  end
+
+  def parse_bare_item
+    case
+    when check(/[-0-9]/)
+      parse_integer_or_decimal
+    when check('"')
+      parse_string
+    when check(/[A-Za-z*]/)
+      parse_token
+    when check(':')
+      parse_byte_sequence
+    when check('?')
+      parse_boolean
+    else
+      parse_error
+    end
+  end
+
+  def parse_parameters
+    output = {}
+    until eos?
+      break unless scan(';')
+      consume_sp
+      key = parse_key
+      if scan('=')
+        value = parse_bare_item
+      else
+        value = true
+      end
+      output[key] = value
+    end
+    output
+  end
+
+  def parse_key
+    parse_error unless check(/[a-z*]/)
+    output = scan(/[a-z0-9_\-.*]*/)
+    if @symbolize_names
+      output.to_sym
+    else
+      output
+    end
+  end
+
+  def parse_integer_or_decimal
+    unless output = scan(/-?(\d+)(\.\d+)?/)
+      parse_error
+    end
+    if @s[2]
+      if @s[1].size > 12 || @s[2].size > 4
+        parse_error
+      end
+      output.to_f
+    else
+      if @s[1].size > 15
+        parse_error
+      end
+      output.to_i
+    end
+  end
+
+  def parse_string
+    expect('"')
+    output = scan(/([\u0020-\u0021\u0023-\u005b\u005d-\u007e]|\\[\\"])*/)
+    expect('"')
+    output.gsub(/\\([\\"])/, '\1')
+  end
+
+  def parse_token
+    check(/[A-Za-z*]/)
+    scan(/[!#$%&'*+\-.^_`|~0-9A-Za-z:\/]*/).to_sym
+  end
+
+  def parse_byte_sequence
+    expect(':')
+    output = scan(/[A-Za-z0-9+\/=]*/)
+    expect(':')
+    Base64.decode64(output)
+  end
+
+  def parse_boolean
+    unless scan(/\?([01])/)
+      parse_error
+    end
+    @s[1] == '1'
+  end
+
+  private
+
+  def_delegators :@s, :check, :scan, :eos?
+
+  def expect(regexp)
+    scan(regexp) || parse_error(regexp)
+  end
+
+  def consume_sp
+    scan(/ */)
+  end
+
+  def consume_ows
+    scan(/[ \t]*/)
+  end
+
+  def parse_error(_ = nil)
+    raise Starry::ParseError
+  end
+
+end

data/lib/starry/version.rb

@@ -0,0 +1,3 @@
+module Starry
+  VERSION = '0.1.0'
+end

data/lib/starry.rb

@@ -0,0 +1,150 @@
+require 'base64'
+
+module Starry
+
+  class SerializeError < ::StandardError; end
+  class ParseError < ::StandardError; end
+
+  class << self
+
+    def serialize(input)
+      case input
+      when {}, []
+        return nil
+      when Hash
+        serialize_dictionary(input)
+      when Enumerable
+        serialize_list(input)
+      else
+        serialize_item(input)
+      end
+    end
+
+    def serialize_list(input)
+      input.map do |item|
+        serialize_item_or_inner_list(item)
+      end.join(', ')
+    end
+
+    def serialize_parameters(input)
+      input.transform_keys(&:to_s).map do |key, value|
+        if value == true
+          ";#{ serialize_key(key) }"
+        else
+          ";#{ serialize_key(key) }=#{ serialize_bare_item(value) }"
+        end
+      end.join('')
+    end
+
+    def serialize_key(input)
+      unless input.match?(/\A[a-z*][a-z0-9_\-.*]*\z/)
+        raise SerializeError, "The given value #{ input.inspect } contains characters that are not allowed as a key for dictionary / parameters in HTTP Structured Field."
+      end
+      input
+    end
+
+    def serialize_dictionary(input)
+      input.transform_keys(&:to_s).map do |key, value|
+        if value == true
+          serialize_key(key)
+        elsif value.kind_of?(Item) && value.value == true
+          "#{ serialize_key(key) }#{ serialize_parameters(value.parameters) }"
+        else
+          "#{ serialize_key(key) }=#{ serialize_item_or_inner_list(value) }"
+        end
+      end.join(', ')
+    end
+
+    def serialize_item(input)
+      if input.kind_of?(Item)
+        input.to_s
+      else
+        serialize_bare_item(input)
+      end
+    end
+
+    def serialize_bare_item(input)
+      case input
+      when Integer
+        if input.abs >= 10 ** 15
+          raise SerializeError, "Integer value in HTTP Structured Field must have an absolute value less than 10 ** 15, but #{ input } given."
+        end
+        input.to_s
+      when Float
+        x = input.round(3, half: :even)
+        if x.abs >= 10 ** 12
+          raise SerializeError, "Numeric value in HTTP Structured Field must have an absolute value less than 10 ** 15, but #{ input } given."
+        end
+        x.to_s
+      when String
+        if input.encoding == Encoding::ASCII_8BIT
+          ":#{ Base64.strict_encode64(input) }:"
+        else
+          unless input.match?(/\A[\u0020-\u007E]*\z/)
+            raise SerializeError, "String value in HTTP Structured Field must consist of only ASCII printable characters, but given value #{ input.inspect } does not meet that."
+          end
+          "\"#{ input.gsub(/\\|"/) { "\\#{ _1 }" } }\""
+        end
+      when Symbol
+        unless input.to_s.match?(/\A[A-Za-z*][!#$%&'*+\-.^_`|~0-9A-Za-z:\/]*\z/)
+          raise SerializeError, "The given value #{ input.inspect } contains characters that are not allowed as Token in HTTP Structured Field."
+        end
+        input.to_s
+      when true
+        '?1'
+      when false
+        '?0'
+      else
+        raise SerializeError, "The given value #{ input.inspect } cannnot be used as a bare item of HTTP Structured Field."
+      end
+    end
+
+    private def serialize_item_or_inner_list(input)
+      case input
+      when InnerList
+        input.to_s
+      when Hash
+        raise SerializeError, "Hash cannnot be used as an item of HTTP Structured Field, but #{ input.inspect } given."
+      when Enumerable
+        InnerList.new(input).to_s
+      when Item
+        case input.value
+        when Hash
+          raise SerializeError, "Hash cannnot be used as an item of HTTP Structured Field, but #{ input.value.inspect } given."
+        when Enumerable
+          InnerList.new(input.value, input.parameters).to_s
+        else
+          input.to_s
+        end
+      else
+        serialize_bare_item(input)
+      end
+    end
+
+    def parse_list(input)
+      ensure_ascii_only(input)
+      Parser.new(input).parse(:list)
+    end
+
+    def parse_dictionary(input)
+      ensure_ascii_only(input)
+      Parser.new(input).parse(:dictionary)
+    end
+
+    def parse_item(input)
+      ensure_ascii_only(input)
+      Parser.new(input).parse(:item)
+    end
+
+    private def ensure_ascii_only(input)
+      unless input.ascii_only?
+        raise ParseError, "Input string contains unexpected non-ASCII character."
+      end
+    end
+  end
+end
+
+require_relative 'starry/inner_list'
+require_relative 'starry/item'
+require_relative 'starry/parser'
+require_relative 'starry/version'

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: starry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Takemaro
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-07 00:00:00.000000000 Z
+dependencies: []
+description:
+email: info@takemaro.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/starry.rb
+- lib/starry/inner_list.rb
+- lib/starry/item.rb
+- lib/starry/parser.rb
+- lib/starry/version.rb
+homepage: https://github.com/takemar/starry
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/takemar/starry/issues
+  homepage_uri: https://github.com/takemar/starry
+  source_code_uri: https://github.com/takemar/starry/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: An implementation of HTTP Structured Field Values (RFC 8941)
+test_files: []