prismic.io 1.0.0.preview.1

data/lib/prismic/fragments/embed.rb

@@ -0,0 +1,23 @@
+module Prismic
+  module Fragments
+    class Embed
+      attr_accessor :embed_type, :provider, :url, :html, :o_embed_json
+
+      def initialize(embed_type, provider, url, html, o_embed_json)
+        @embed_type   = embed_type
+        @provider     = provider
+        @url          = url
+        @html         = html
+        @o_embed_json = o_embed_json
+      end
+
+      def as_html(link_resolver=nil)
+        <<-HTML
+        <div data-oembed="#@url"
+            data-oembed-type="#{@embed_type.downcase}"
+            data-oembed-provider="#{@provider.downcase}">#@html</div>
+        HTML
+      end
+    end
+  end
+end

data/lib/prismic/fragments/image.rb

@@ -0,0 +1,47 @@
+module Prismic
+  module Fragments
+    class Image
+      attr_accessor :main, :views
+
+      def initialize(main, views)
+        @main = main
+        @views = views
+      end
+
+      def as_html(link_resolver=nil)
+        main.as_html(link_resolver)
+      end
+
+      def get_view(key)
+        if key == 'main'
+          main
+        elsif @views.has_key?(key)
+          views[key]
+        else
+          raise ViewDoesNotExistException
+        end
+      end
+
+      class ViewDoesNotExistException < Error ; end
+
+      class View
+        attr_accessor :url, :width, :height
+
+        def initialize(url, width, height)
+          @url = url
+          @width = width
+          @height = height
+        end
+
+        def ratio
+          return @width / @height
+        end
+
+        def as_html(link_resolver=nil)
+          %(<img src="#@url" width="#@width" height="#@height" />)
+        end
+
+      end
+    end
+  end
+end

data/lib/prismic/fragments/link.rb

@@ -0,0 +1,47 @@
+module Prismic
+  module Fragments
+    class Link
+      def as_html(link_resolver=nil)
+        %(<a href="#@url">#@url</a>)
+      end
+    end
+
+    class WebLink < Link
+      attr_accessor :url
+
+      def initialize(url)
+        @url = url
+      end
+    end
+
+    class MediaLink < Link
+      attr_accessor :url
+
+      def initialize(url)
+        @url = url
+      end
+    end
+
+    class DocumentLink < Link
+      attr_accessor :id, :link_type, :tags, :slug, :broken
+
+      def initialize(id, link_type, tags, slug, broken)
+        @id = id
+        @link_type = link_type
+        @tags = tags
+        @slug = slug
+        @broken = broken
+      end
+
+      def as_html(link_resolver)
+        if broken?
+          %(<span>#{slug}</span>)
+        else
+          %(<a href="#{link_resolver.link_to(self)}">#{slug}</a>)
+        end
+      end
+
+      alias :broken? :broken
+    end
+  end
+end

data/lib/prismic/fragments/multiple.rb

@@ -0,0 +1,29 @@
+module Prismic
+  module Fragments
+    class Multiple
+      attr_reader :fragments
+
+      def initialize(fragments=[])
+        @fragments = fragments
+      end
+
+      def size
+        @fragments.size
+      end
+
+      def [](i)
+        @fragments[i]
+      end
+
+      def push(fragment)
+        @fragments.push(fragment)
+      end
+
+      def as_html(link_resolver)
+        @fragments.map { |f| f.as_html(link_resolver) }.join
+      end
+
+      alias :length :size
+    end
+  end
+end

data/lib/prismic/fragments/number.rb

@@ -0,0 +1,19 @@
+module Prismic
+  module Fragments
+    class Number
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def as_int
+        @value.to_int
+      end
+
+      def as_html(link_resolver=nil)
+        %(<span class="number">#@value</span>)
+      end
+    end
+  end
+end

data/lib/prismic/fragments/select.rb

@@ -0,0 +1,15 @@
+module Prismic
+  module Fragments
+    class Select
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def as_html(link_resolver=nil)
+        %(<span class="text">#@value</span>)
+      end
+    end
+  end
+end

data/lib/prismic/fragments/structured_text.rb

@@ -0,0 +1,200 @@
+module Prismic
+  module Fragments
+    class StructuredText
+      class Group
+        attr_reader :kind, :blocks
+        def initialize(kind)
+          @kind = kind
+          @blocks = []
+        end
+        def <<(block)
+          blocks << block
+        end
+      end
+      attr_accessor :blocks
+
+      def initialize(blocks)
+        @blocks = blocks
+      end
+
+      def as_html(link_resolver)
+        block_group = ->(block){
+          case block
+          when Block::ListItem
+            block.ordered? ? "ol" : "ul"
+          else
+            nil
+          end
+        }
+        groups, last = [], nil
+        blocks.each {|block|
+          group = block_group.(block)
+          groups << Group.new(group) if !last || group != last
+          groups.last << block
+          last = group
+        }
+        groups.map{|group|
+          html = group.blocks.map{|b| b.as_html(link_resolver) }.join
+          case group.kind
+          when "ol"
+            %(<ol>#{html}</ol>)
+          when "ul"
+            %(<ul>#{html}</ul>)
+          else
+            html
+          end
+        }.join("\n\n")
+      end
+
+      class Span
+        attr_accessor :start, :end
+
+        def initialize(start, finish)
+          @start = start
+          @end = finish
+        end
+
+        class Em < Span
+          def start_html(link_resolver=nil)
+            "<em>"
+          end
+          def end_html(link_resolver=nil)
+            "</em>"
+          end
+        end
+
+        class Strong < Span
+          def start_html(link_resolver=nil)
+            "<b>"
+          end
+          def end_html(link_resolver=nil)
+            "</b>"
+          end
+        end
+
+        class Hyperlink < Span
+          attr_accessor :link
+          def initialize(start, finish, link)
+            super(start, finish)
+            @link = link
+          end
+          def start_html(link_resolver)
+            # Quick-and-dirty way to generate the right <a> tag
+            link.as_html(link_resolver).sub(/(<a[^>]+>).*/, '\1')
+          end
+          def end_html(link_resolver=nil)
+            "</a>"
+          end
+        end
+      end
+
+      class Block
+        class Text
+          attr_accessor :text, :spans
+
+          def initialize(text, spans)
+            @text = text
+            @spans = spans
+          end
+
+          def as_html(link_resolver=nil)
+            start_spans, end_spans = prepare_spans
+            text.chars.each_with_index.map {|c, i|
+              opening = start_spans[i].map {|span|
+                span.start_html(link_resolver)
+              }
+              closing = end_spans[i].map {|span|
+                span.end_html(link_resolver)
+              }
+              opening + closing + [c]
+            }.flatten.join("")
+          end
+
+          def prepare_spans
+            unless defined?(@prepared_spans)
+              start_spans = Hash.new{|h,k| h[k] = [] }
+              end_spans = Hash.new{|h,k| h[k] = [] }
+              spans.each {|span|
+                start_spans[span.start] << span
+                end_spans[span.end] << span
+              }
+              @start_spans = start_spans
+              @end_spans = end_spans
+            end
+            [@start_spans, @end_spans]
+          end
+        end
+
+        class Heading < Text
+          attr_accessor :level
+
+          def initialize(text, spans, level)
+            super(text, spans)
+            @level = level
+          end
+
+          def as_html(link_resolver=nil)
+            %(<h#{level}>#{super}</h#{level}>)
+          end
+        end
+
+        class Paragraph < Text
+          def as_html(link_resolver=nil)
+            %(<p>#{super}</p>)
+          end
+        end
+
+        class ListItem < Text
+          attr_accessor :ordered
+          alias :ordered? :ordered
+
+          def initialize(text, spans, ordered)
+            super(text, spans)
+            @ordered = ordered
+          end
+
+          def as_html(link_resolver)
+            %(<li>#{super}</li>)
+          end
+        end
+
+        class Image < Block
+          attr_accessor :view
+
+          def initialize(view)
+            @view = view
+          end
+
+          def url
+            @view.url
+          end
+
+          def width
+            @view.width
+          end
+
+          def height
+            @view.height
+          end
+
+          def as_html(link_resolver)
+            view.as_html(link_resolver)
+          end
+        end
+
+        class Embed < Block
+
+          def initialize(embed)
+            @embed
+          end
+
+          def as_html(link_resolver)
+            embed.as_html(link_resolver)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/prismic/fragments/text.rb

@@ -0,0 +1,15 @@
+module Prismic
+  module Fragments
+    class Text
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def as_html(link_resolver=nil)
+        %(<span class="text">#@value</span>)
+      end
+    end
+  end
+end

data/lib/prismic/json_parsers.rb

@@ -0,0 +1,174 @@
+module Prismic
+  module JsonParser
+    class << self
+      def parsers
+        @parsers ||= {
+          'Link.document'  => method(:document_link_parser),
+          'Text'           => method(:text_parser),
+          'Link.web'       => method(:web_link_parser),
+          'Date'           => method(:date_parser),
+          'Number'         => method(:number_parser),
+          'Embed'          => method(:embed_parser),
+          'Image'          => method(:image_parser),
+          'Color'          => method(:color_parser),
+          'StructuredText' => method(:structured_text_parser),
+          'Select'         => method(:select_parser),
+          'Multiple'       => method(:multiple_parser),
+        }
+      end
+
+      def document_link_parser(json)
+        Prismic::Fragments::DocumentLink.new(
+          json['value']['document']['id'],
+          json['value']['document']['type'],
+          json['value']['document']['tags'],
+          json['value']['document']['slug'],
+          json['value']['isBroken'])
+      end
+
+      def text_parser(json)
+        Prismic::Fragments::Text.new(json['value'])
+      end
+
+      def select_parser(json)
+        Prismic::Fragments::Text.new(json['value'])
+      end
+
+      def web_link_parser(json)
+        Prismic::Fragments::WebLink.new(json['value']['url'])
+      end
+
+      def date_parser(json)
+        Prismic::Fragments::Date.new(Time.parse(json['value']))
+      end
+
+      def number_parser(json)
+        Prismic::Fragments::Number.new(json['value'])
+      end
+
+      def embed_parser(json)
+        Prismic::Fragments::Embed.new(
+          json['value']['oembed']['type'],
+          json['value']['oembed']['provider_name'],
+          json['value']['oembed']['provider_url'],
+          json['value']['oembed']['html'],
+          json['value']['oembed']
+        )
+      end
+
+      def image_parser(json)
+        def self.view_parser(json)
+          Prismic::Fragments::Image::View.new(json['url'],
+                                              json['dimensions']['width'],
+                                              json['dimensions']['height'])
+        end
+
+        main  = view_parser(json['value']['main'])
+        views = json['value']['views'].map do |name, view|
+          view_parser(view)
+        end
+
+        Prismic::Fragments::Image.new(main, views)
+      end
+
+      def color_parser(json)
+        Prismic::Fragments::Color.new(json['value'][1..6])
+      end
+
+      def structured_text_parser(json)
+        def self.span_parser(span)
+          case span['type']
+          when 'em'
+            Prismic::Fragments::StructuredText::Span::Em.new(span['start'], span['end'])
+          when 'strong'
+            Prismic::Fragments::StructuredText::Span::Strong.new(span['start'], span['end'])
+          when 'hyperlink'
+            Prismic::Fragments::StructuredText::Span::Hyperlink.new(span['start'], span['end'], link_parser(span['data']))
+          else
+            puts "Unknown span_parser type: #{span['type']}"
+          end
+        end
+
+        blocks = json['value'].map do |block|
+          case block['type']
+          when 'paragraph'
+            spans = block['spans'].map {|span| span_parser(span) }
+            Prismic::Fragments::StructuredText::Block::Paragraph.new(block['text'], spans)
+          when /^heading/
+            spans = block['spans'].map {|span| span_parser(span) }
+            Prismic::Fragments::StructuredText::Block::Heading.new(
+              block['text'],
+              spans,
+              block['type'][-1].to_i
+            )
+          when 'o-list-item'
+            spans = block['spans'].map {|span| span_parser(span) }
+            Prismic::Fragments::StructuredText::Block::ListItem.new(
+              block['text'],
+              spans,
+              true  # ordered
+            )
+          when 'list-item'
+            spans = block['spans'].map {|span| span_parser(span) }
+            Prismic::Fragments::StructuredText::Block::ListItem.new(
+              block['text'],
+              spans,
+              false  # unordered
+            )
+          when 'image'
+            view = Prismic::Fragments::Image::View.new(
+              block['url'],
+              block['dimensions']['width'],
+              block['dimensions']['height']
+            )
+            Prismic::Fragments::StructuredText::Block::Image.new(view)
+          when 'embed'
+            embed = Prismic::Fragments::Embed.new(
+              block['oembed']['type'],
+              block['oembed']['provider_name'],
+              block['oembed']['provider_url'],
+              block['oembed']['html'],
+              block['oembed']
+            )
+            Prismic::Fragments::StructuredText::Block::Image.new(embed)
+          else
+            puts "Unknown bloc type: #{block['type']}"
+          end
+        end
+        Prismic::Fragments::StructuredText.new(blocks)
+      end
+
+      def multiple_parser(json)
+        fragments = json.map do |fragment|
+          parsers[fragment['type']].call(fragment)
+        end
+        Prismic::Fragments::Multiple.new(fragments)
+      end
+
+      def document_parser(json)
+        fragments = Hash[json['data'].values.first.map do |name, fragment|
+          if fragment.is_a? Array
+            [name, multiple_parser(fragment)]
+          else
+            [name, parsers[fragment['type']].call(fragment)]
+          end
+        end]
+
+        Prismic::Document.new(json['id'], json['type'], json['href'], json['tags'],
+                              json['slugs'], fragments)
+      end
+
+      private
+
+      private
+
+      def link_parser(json)
+        if json['type'] == 'Link.document'
+          document_link_parser(json)
+        elsif json['type'] == 'Link.web'
+          web_link_parser(json)
+        end
+      end
+    end
+  end
+end