corpshort 0.1.0

data/lib/corpshort/backends/base.rb

@@ -0,0 +1,34 @@
+module Corpshort
+  module Backends
+    class Base
+      class ConflictError < StandardError; end
+
+      def initialize()
+      end
+
+      def put_link(link, create_only: false)
+        raise NotImplementedError
+      end
+
+      def get_link(name)
+        raise NotImplementedError
+      end
+
+      def delete_link(link_or_name)
+        raise NotImplementedError
+      end
+
+      def rename_link(link, new_name)
+        raise NotImplementedError
+      end
+
+      def list_links_by_url(url)
+        raise NotImplementedError
+      end
+
+      def list_links(token: nil, limit: 30)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/corpshort/backends/dynamodb.rb

@@ -0,0 +1,114 @@
+require 'aws-sdk-dynamodb'
+require 'date'
+require 'time'
+require 'corpshort/backends/base'
+require 'corpshort/link'
+
+module Corpshort
+  module Backends
+    class Dynamodb < Base
+      def initialize(table:, region:)
+        @table_name = table
+        @region = region
+      end
+
+      def table
+        @table ||= dynamodb.table(@table_name)
+      end
+
+      def dynamodb
+        @dynamodb ||= Aws::DynamoDB::Resource.new(region: @region)
+      end
+
+      def put_link(link, create_only: false)
+        table.update_item(
+          key: {
+            'name' => link.name,
+          },
+          update_expression: 'SET #u = :url, updated_at_partition = :ts_partition, updated_at = :updated_at',
+          condition_expression: create_only ? 'attribute_not_exists(#n)' : nil,
+          expression_attribute_names: create_only ? {'#u' => 'url', '#n' => 'name'} : {'#u' => 'url'},
+          expression_attribute_values: {
+            ':url' => link.url,
+            ':ts_partition' => ts_partition(link.updated_at),
+            ':updated_at' => link.updated_at.iso8601,
+          },
+        )
+      rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+        raise ConflictError
+      end
+
+      def get_link(name)
+        item = table.query(
+          limit: 1,
+          select: 'ALL_ATTRIBUTES',
+          key_condition_expression: '#n = :name',
+          expression_attribute_names: {'#n' => 'name'},
+          expression_attribute_values: {":name" => name},
+        ).items.first
+
+        if item && !item.empty?
+          Link.new(item, backend: self)
+        else
+          nil
+        end
+      end
+
+      def delete_link(link)
+        name = link.is_a?(String) ? link : link.name
+        table.delete_item(
+          key: {
+            'name' => name,
+          },
+        )
+      end
+
+      def list_links_by_url(url)
+        table.query(
+          index_name: 'url-updated_at-index',
+          select: 'ALL_PROJECTED_ATTRIBUTES',
+          key_condition_expression: '#u = :url',
+          expression_attribute_names: {"#u" => 'url'},
+          expression_attribute_values: {":url" => url},
+        ).items.map { |_| _['name'] }
+      end
+
+      def list_links(token: nil, limit: 30)
+        partition, last_key = parse_token(token)
+        limit.times do
+          result = table.query(
+            index_name: 'updated_at_partition-updated_at-index',
+            select: 'ALL_PROJECTED_ATTRIBUTES',
+            scan_index_forward: false,
+            exclusive_start_key: last_key ? last_key : nil,
+            key_condition_expression: 'updated_at_partition = :partition',
+            expression_attribute_values: {":partition" => partition.strftime('%Y-%m')},
+            limit: 1 || limit,
+          )
+
+          unless result.items.empty?
+            return [result.items.map{ |_| _['name'] }, result.last_evaluated_key&.values_at('updated_at_partition', 'name', 'updated_at')&.join(?:)]
+          end
+
+          partition = partition.to_date.prev_month
+          last_key = nil
+          sleep 0.05
+        end
+      end
+
+      private
+
+      def parse_token(token)
+        if token.nil?
+          return [Time.now, nil]
+        end
+        partition, name, ts = token.split(?:,3)
+        [Time.strptime(partition, '%Y-%m'), ts ? {"updated_at_partition" => partition, "updated_at" => ts, "name" => name} : nil]
+      end
+
+      def ts_partition(time)
+        time.strftime('%Y-%m')
+      end
+    end
+  end
+end

data/lib/corpshort/backends/memory.rb

@@ -0,0 +1,61 @@
+require 'thread'
+require 'corpshort/backends/base'
+require 'corpshort/link'
+
+module Corpshort
+  module Backends
+    class Memory < Base
+      def initialize()
+        @lock = Mutex.new
+        @links = {}
+        @links_by_url = {}
+      end
+
+      attr_reader :links, :links_by_url
+
+      def put_link(link, create_only: false)
+        @lock.synchronize do
+          old_link = @links[link.name]
+          if create_only && old_link
+            raise ConflictError
+          end
+          old_url = old_link&.fetch(:url, nil)
+          if old_link && link.url != old_url
+            @links_by_url[old_url].delete(link.name)
+          end
+          @links[link.name] = link.to_h
+          (@links_by_url[link.url] ||= {})[link.name] = true
+        end
+        nil
+      end
+
+      def get_link(name)
+        data = @links[name]
+        if data && !data.empty?
+          Link.new(data, backend: self)
+        else
+          nil
+        end
+      end
+
+      def delete_link(link)
+        @lock.synchronize do
+          name = link.is_a?(String) ? link : link.name
+          data = @links[name]
+          if @links[name]
+            @links.delete name
+            @links_by_url[data[:url]].delete name
+          end
+        end
+      end
+
+      def list_links_by_url(url)
+        @links_by_url[url].keys
+      end
+
+      def list_links(token: nil, limit: 30)
+        [@links.keys, nil]
+      end
+    end
+  end
+end

data/lib/corpshort/backends/redis.rb

@@ -0,0 +1,121 @@
+require 'digest/sha2'
+require 'redis'
+
+require 'corpshort/backends/base'
+require 'corpshort/link'
+
+module Corpshort
+  module Backends
+    class Redis < Base
+      def initialize(redis: ::Redis.method(:current), prefix: "corpshort:")
+        @redis = redis
+        @prefix = prefix
+      end
+
+      attr_reader :prefix
+
+      def put_link(link, create_only: false)
+        key = link_key(link)
+
+        redis.watch(key) do 
+          old_url = redis.hget(key, 'url')
+
+          if create_only && old_url
+            redis.unwatch(key)
+            raise ConflictError, "#{link.name} already exists"
+          end
+
+          redis.multi do |m|
+            m.del(key)
+            m.mapped_hmset(key, link.as_json)
+            m.zadd(links_key, link.updated_at.to_i, link.name)
+
+            if old_url && link.url != old_url
+              m.zrem(url_key(old_url), link.name)
+            end
+            m.zadd(url_key(link.url), link.updated_at.to_i, link.name)
+          end
+        end
+      end
+
+      def get_link(name)
+        data = redis.hgetall(link_key(name))
+        if data && !data.empty?
+          Link.new(data, backend: self)
+        else
+          nil
+        end
+      end
+
+      def delete_link(link)
+        key = link_key(link)
+        redis.watch(key) do
+          url = redis.hget(key, 'url')
+          link_url_key = url_key(url)
+
+          redis.multi do |m|
+            m.zrem(links_key, link)
+            m.zrem(link_url_key, link)
+            m.del(key)
+          end
+        end
+      end
+
+      def rename_link(link, new_name)
+        link_key = link_key(link)
+        new_key = link_key(new_name)
+
+        redis.watch(link_key) do
+          url = redis.hget(link_key, 'url')
+          link_url_key = url_key(url)
+
+          redis.multi do |m|
+            m.renamenx(link_key, new_key)
+            m.hset(new_key, 'name', new_name)
+            m.zrem(links_key, link.name)
+            m.zadd(links_key, link.updated_at.to_i, new_name)
+            m.zrem(link_url_key, link.name)
+            m.zadd(link_url_key, link.updated_at.to_i, new_name)
+          end
+        end
+      end
+
+      def list_links_by_url(url)
+        redis.zrevrangebyscore(url_key(url), '+inf', '-inf')
+      end
+
+      def list_links(token: nil, limit: 30)
+        names = if token
+                  redis.zrevrangebyscore(links_key, "(#{token}", '-inf', limit: [0, limit], with_scores: true)
+                else
+                  redis.zrevrangebyscore(links_key, '+inf', '-inf', limit: [0, limit], with_scores: true)
+                end
+
+        [names.map(&:first), names[-1]&.last]
+      end
+
+      def redis
+        Thread.current[redis_thread_key] ||= @redis.call
+      end
+
+      private
+
+      def url_key(url)
+        "#{@prefix}url:#{Digest::SHA384.hexdigest(url)}"
+      end
+
+      def links_key
+        "#{@prefix}links"
+      end
+
+      def link_key(link)
+        name = link.is_a?(String) ? link : link.name
+        "#{@prefix}link:#{name}"
+      end
+
+      def redis_thread_key
+        @redis_thread_key ||= :"corpshort_backend_redis_#{self.__id__}"
+      end
+    end
+  end
+end

data/lib/corpshort/horizontal_pdf.rb

@@ -0,0 +1,105 @@
+require 'prawn'
+require 'prawn/qrcode'
+
+module Corpshort
+  class HorizontalPdf
+    include Prawn::Measurements
+
+    def initialize(url:, base_url:, name:, flex: false)
+      @url = url
+      @base_url = base_url
+      @name = name
+
+      @flex = flex
+
+      if @flex
+        @width = code_size + required_width_for_url_box + padding + padding + padding
+      end
+    end
+
+    def w
+      @width || cm2pt(7)
+    end
+
+    def h
+      cm2pt(3)
+    end
+
+    def code_size
+      cm2pt(3)
+    end
+
+    def padding
+      cm2pt(0.2)
+    end
+
+    def text
+      [
+        {link: @url, text: @base_url},
+        {link: @url, text: '/'},
+        {link: @url, styles: [:bold], text: @name},
+      ]
+    end
+
+    def required_width_for_url_box
+      doc = Prawn::Document.new(page_size: [cm2pt(5),cm2pt(5)], margin: 0)
+      doc.font_size = 12
+      text.inject(0) do |r,t|
+        r + doc.width_of(t.fetch(:text), style: t[:styles]&.first)
+      end
+    end
+
+    def url_box
+      Prawn::Text::Formatted::Box.new(
+        text,
+        document: pdf,
+        at: [code_size, code_size],
+        width: w - code_size - padding - padding,
+        height: h,
+        overflow: :shrink_to_fit,
+        min_font_size: nil,
+        disable_wrap_by_char: true,
+        align: :left,
+        valign: :center,
+        kerning: true,
+      )
+    end
+
+    def render
+      @pdf = nil
+
+      pdf.fill_color 'FFFFFF'
+      pdf.fill { pdf.rounded_rectangle [0, code_size], code_size, code_size, 10 }
+      pdf.print_qr_code(@url, level: :m, extent: code_size, stroke: false)
+
+      [true, false].each do |dry_run|
+        box = url_box()
+        box.render(dry_run: dry_run)
+        if dry_run
+          pdf.fill_color 'FFFFFF'
+          pdf.fill do
+            pdf.rounded_rectangle(
+              [box.at[0] - padding, box.at[1] + padding],
+              box.available_width + padding + padding,
+              box.height + padding + padding,
+              5,
+            )
+          end
+          pdf.fill_color '000000'
+        end
+      end
+
+      pdf
+    end
+
+    def document
+      render
+    end
+
+    def pdf
+      @pdf ||= Prawn::Document.new(page_size: [w,h], margin: 0).tap do |pdf|
+        pdf.font_size = 12
+      end
+    end
+  end
+end

data/lib/corpshort/link.rb

@@ -0,0 +1,83 @@
+require 'time'
+require 'json'
+
+module Corpshort
+  class Link
+    class NoBackendError < StandardError; end
+    class ValidationError < StandardError; end
+
+    NAME_REGEXP = %r{\A[a-zA-Z0-9./\-_]+\z}
+
+    def self.validate_name(name)
+      raise ValidationError, "@name should satisfy #{NAME_REGEXP}" unless name.match?(NAME_REGEXP)
+    end
+
+    def initialize(data, backend: nil)
+      @backend = backend
+
+      @name = data[:name] || data['name']
+      @url = data[:url] || data['url']
+      @parsed_url_point = nil
+      self.updated_at = data[:updated_at] || data['updated_at']
+
+      validate!
+    end
+
+    def validate!
+      raise ValidationError, "@name, @url are required" unless name && url
+      raise ValidationError, "invalid @url (URL needs scheme and host to be considered valid)" unless parsed_url.scheme && parsed_url.host
+      self.class.validate_name(name)
+    end
+
+    def save!(backend = nil, create_only: false)
+      @backend = backend if backend
+      raise NoBackendError unless @backend
+      validate!
+      self.updated_at = Time.now
+      @backend.put_link(self, create_only: create_only)
+    end
+
+    attr_reader :backend
+    attr_reader :name, :updated_at
+    attr_accessor :url
+
+    def parsed_url
+      @parsed_url = nil if @parsed_url_point != url
+      @parsed_url ||= url.yield_self do |u|
+        @parsed_url_point = u
+        URI.parse(u)
+      end
+    end
+
+    def updated_at=(ts)
+      @updated_at = case ts
+      when Time
+        ts
+      when String
+        Time.iso8601(ts)
+      when nil
+        nil
+      else
+        raise TypeError, "link.updated_at must be a Time or a String (ISO 8601 formatted)"
+      end
+    end
+
+    def to_h
+      {
+        name: name,
+        url: url,
+        updated_at: updated_at,
+      }
+    end
+
+    def as_json
+      to_h.tap do |h|
+        h[:updated_at] = h[:updated_at].iso8601 if h[:updated_at]
+      end
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end