notion_ruby_mapping 0.1.2 → 0.2.0

data/lib/notion_ruby_mapping/property.rb

@@ -4,21 +4,25 @@ module NotionRubyMapping
   # abstract class for property
   class Property
     # @param [String] name Property name
-    # @param [Hash] json
     # @return [Property] generated Property object
-    def initialize(name, json: nil)
+    def initialize(name, will_update: false)
       @name = name
-      @will_update = false
-      @json = json
+      @will_update = will_update
     end
     attr_reader :name
-    attr_accessor :will_update
+
+    # @return [TrueClass, FalseClass]
+    attr_reader :will_update
 
     # @param [String] key query parameter
     # @param [Object] value query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def make_filter_query(key, value)
-      Query.new(filter: {"property" => @name, type => {key => value}})
+    def make_filter_query(key, value, rollup = nil, rollup_type = nil)
+      if rollup
+        Query.new filter: {"property" => @name, rollup => {rollup_type => {key => value}}}
+      else
+        Query.new filter: {"property" => @name, type => {key => value}}
+      end
     end
 
     # @return [Symbol] property type
@@ -26,19 +30,53 @@ module NotionRubyMapping
       self.class::TYPE
     end
 
-    # @param [String] key
+    # @param [String] name
     # @param [Hash] input_json
     # @return [NotionRubyMapping::Property, nil] generated Property object
-    def self.create_from_json(key, input_json)
-      keys = input_json.keys
-      if keys.include? "number"
-        NumberProperty.new key, json: input_json["number"]
-      elsif keys.include? "select"
-        SelectProperty.new key, json: input_json["select"]
-      elsif keys.include? "multi_select"
-        MultiSelectProperty.new key, json: input_json["multi_select"]
+    def self.create_from_json(name, input_json)
+      raise StandardError, "Property not found: #{name}:#{input_json}" if input_json.nil?
+
+      case input_json["type"]
+      when "number"
+        NumberProperty.new name, number: input_json["number"]
+      when "select"
+        SelectProperty.new name, json: input_json["select"]
+      when "multi_select"
+        MultiSelectProperty.new name, json: input_json["multi_select"]
+      when "date"
+        DateProperty.new name, json: input_json["date"]
+      when "title"
+        TitleProperty.new name, json: input_json["title"]
+      when "rich_text"
+        RichTextProperty.new name, json: input_json["rich_text"]
+      when "checkbox"
+        CheckboxProperty.new name, checkbox: input_json["checkbox"]
+      when "people"
+        PeopleProperty.new name, json: input_json["people"]
+      when "email"
+        EmailProperty.new name, email: input_json["email"]
+      when "url"
+        UrlProperty.new name, url: input_json["url"]
+      when "phone_number"
+        PhoneNumberProperty.new name, phone_number: input_json["phone_number"]
+      when "files"
+        FilesProperty.new name, json: input_json["files"]
+      when "created_time"
+        CreatedTimeProperty.new name, created_time: input_json["created_time"]
+      when "last_edited_time"
+        LastEditedTimeProperty.new name, last_edited_time: input_json["last_edited_time"]
+      when "created_by"
+        CreatedByProperty.new name, json: input_json["created_by"]
+      when "last_edited_by"
+        LastEditedByProperty.new name, json: input_json["last_edited_by"]
+      when "formula"
+        FormulaProperty.new name, json: input_json["formula"]
+      when "rollup"
+        RollupProperty.new name, json: input_json["rollup"]
+      when "relation"
+        RelationProperty.new name, json: input_json["relation"]
       else
-        nil
+        raise StandardError, "Irregular property type: #{input_json["type"]}"
       end
     end
   end
@@ -47,14 +85,14 @@ module NotionRubyMapping
   module EqualsDoesNotEqual
     # @param [String, Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_equals(value)
-      make_filter_query "equals", value
+    def filter_equals(value, rollup = nil, rollup_type = nil)
+      make_filter_query "equals", value, rollup, rollup_type
     end
 
     # @param [String, Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_does_not_equal(value)
-      make_filter_query "does_not_equal", value
+    def filter_does_not_equal(value, rollup = nil, rollup_type = nil)
+      make_filter_query "does_not_equal", value, rollup, rollup_type
     end
   end
 
@@ -62,14 +100,14 @@ module NotionRubyMapping
   module ContainsDoesNotContain
     # @param [String] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_contains(value)
-      make_filter_query "contains", value
+    def filter_contains(value, rollup = nil, rollup_type = nil)
+      make_filter_query "contains", value, rollup, rollup_type
     end
 
     # @param [String] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_does_not_contain(value)
-      make_filter_query "does_not_contain", value
+    def filter_does_not_contain(value, rollup = nil, rollup_type = nil)
+      make_filter_query "does_not_contain", value, rollup, rollup_type
     end
   end
 
@@ -77,27 +115,27 @@ module NotionRubyMapping
   module StartsWithEndsWith
     # @param [String] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_starts_with(value)
-      make_filter_query "starts_with", value
+    def filter_starts_with(value, rollup = nil, rollup_type = nil)
+      make_filter_query "starts_with", value, rollup, rollup_type
     end
 
     # @param [String] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_ends_with(value)
-      make_filter_query "ends_with", value
+    def filter_ends_with(value, rollup = nil, rollup_type = nil)
+      make_filter_query "ends_with", value, rollup, rollup_type
     end
   end
 
   # module for make query of is_empty and is_not_empty
   module IsEmptyIsNotEmpty
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_is_empty
-      make_filter_query "is_empty", true
+    def filter_is_empty(rollup = nil, rollup_type = nil)
+      make_filter_query "is_empty", true, rollup, rollup_type
     end
 
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_is_not_empty
-      make_filter_query "is_not_empty", true
+    def filter_is_not_empty(rollup = nil, rollup_type = nil)
+      make_filter_query "is_not_empty", true, rollup, rollup_type
     end
   end
 
@@ -105,26 +143,26 @@ module NotionRubyMapping
   module GreaterThanLessThan
     # @param [Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_greater_than(value)
-      make_filter_query "greater_than", value
+    def filter_greater_than(value, rollup = nil, rollup_type = nil)
+      make_filter_query "greater_than", value, rollup, rollup_type
     end
 
     # @param [Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_less_than(value)
-      make_filter_query "less_than", value
+    def filter_less_than(value, rollup = nil, rollup_type = nil)
+      make_filter_query "less_than", value, rollup, rollup_type
     end
 
     # @param [Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_greater_than_or_equal_to(value)
-      make_filter_query "greater_than_or_equal_to", value
+    def filter_greater_than_or_equal_to(value, rollup = nil, rollup_type = nil)
+      make_filter_query "greater_than_or_equal_to", value, rollup, rollup_type
     end
 
     # @param [Number] value Query value
     # @return [NotionRubyMapping::Query] generated Query object
-    def filter_less_than_or_equal_to(value)
-      make_filter_query "less_than_or_equal_to", value
+    def filter_less_than_or_equal_to(value, rollup = nil, rollup_type = nil)
+      make_filter_query "less_than_or_equal_to", value, rollup, rollup_type
     end
   end
 end

data/lib/notion_ruby_mapping/property_cache.rb

@@ -1,36 +1,55 @@
+# frozen_string_literal: true
+
 module NotionRubyMapping
+  # PropertyCache class
   class PropertyCache
+    include Enumerable
     def initialize(json = {})
       @properties = {}
       @json = json
     end
+    attr_writer :json
 
     # @param [String] key
     # @return [Property] Property for key
     def [](key)
-      ans = @properties[key]
-      unless ans
-        if @json && @json[key]
-          @properties[key] = Property.create_from_json key, @json[key]
-        end
+      @properties[key] ||= Property.create_from_json key, @json[key]
+    end
+
+    # @param [Array] key
+    # @return [Array]
+    def values_at(*key)
+      generate_all_properties
+      @properties.values_at(*key)
+    end
+
+    def generate_all_properties
+      if @json.empty?
+        @properties.values
+      else
+        @json.keys.map { |key| self[key] }
       end
-      @properties[key]
+    end
+
+    # @return [Hash, Enumerator]
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      generate_all_properties.each(&block)
     end
 
     # @param [Property] property added Property
-    # @param [FalseClass] will_update true if the property value will update to Notion
-    def add_property(property, will_update: false)
+    def add_property(property)
       @properties[property.name] = property
-      property.will_update = true if will_update
       self
     end
 
     # @return [Hash] created json
-    def create_json
-      @properties.each_with_object({}) do |(key, property), ans|
+    def property_values_json
+      @properties.each_with_object({}) do |(_, property), ans|
         if property.will_update
           ans["properties"] ||= {}
-          ans["properties"][key] = property.create_json
+          ans["properties"].merge! property.property_values_json
         end
       end
     end

data/lib/notion_ruby_mapping/query.rb

@@ -3,11 +3,14 @@
 module NotionRubyMapping
   # Query object
   class Query
-    def initialize(filter: {}, sort: [])
+    def initialize(filter: {}, sort: [], page_size: 100, start_cursor: nil)
       @filter = filter
       @sort = sort
+      @page_size = page_size
+      @start_cursor = start_cursor
     end
-    attr_reader :filter, :sort
+    attr_reader :filter, :sort, :page_size
+    attr_accessor :start_cursor
 
     # @param [Query] other_query other query
     # @return [NotionRubyMapping::Query] updated self (Query object)

data/lib/notion_ruby_mapping/relation_property.rb

@@ -4,5 +4,42 @@ module NotionRubyMapping
   # MultiSelect property
   class RelationProperty < MultiProperty
     TYPE = "relation"
+
+    # @param [String] name
+    # @param [Hash] json
+    # @param [String, Array<String>] relation
+    def initialize(name, will_update: false, json: nil, relation: nil)
+      super name, will_update: will_update
+      @relation = if relation
+                    Array(relation)
+                  elsif json
+                    json.map { |r| r["id"] }
+                  else
+                    []
+                  end
+    end
+
+    # @param [String, Array<String>] relation a id or Array of id
+    # @return [Array<String>] settled relation Array
+    def relation=(relation)
+      @will_update = true
+      @relation = Array(relation)
+    end
+
+    # @param [Hash] json
+    def update_from_json(json)
+      @will_update = false
+      @relation = json["relation"].map { |r| r["id"] }
+    end
+
+    # @return [Hash] created json
+    def property_values_json
+      {
+        @name => {
+          "type" => "relation",
+          "relation" => @relation.map { |rid| {"id" => rid} },
+        },
+      }
+    end
   end
 end

data/lib/notion_ruby_mapping/rich_text_object.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module NotionRubyMapping
+  # RichTextObject
+  class RichTextObject
+    # @param [String] type
+    # @return [TextObject]
+    def initialize(type, options = {})
+      if instance_of?(RichTextObject)
+        raise StandardError,
+              "RichTextObject is abstract class.  Please use TextObject."
+      end
+
+      @type = type
+      @options = options
+    end
+
+    def self.create_from_json(json)
+      type = json["type"]
+      options = (json["annotations"] || {}).merge(json.slice("plain_text", "href"))
+      case type
+      when "text"
+        TextObject.new json["plain_text"], options
+      when "mention"
+        mention = json["mention"]
+        case mention["type"]
+        when "user"
+          MentionObject.new options.merge({"user_id" => mention["user"]["id"]})
+        when "page"
+          MentionObject.new options.merge({"page_id" => mention["page"]["id"]})
+        when "database"
+          MentionObject.new options.merge({"database_id" => mention["database"]["id"]})
+        when "date"
+          MentionObject.new options.merge(mention["date"].slice("start", "end", "time_zone"))
+        else
+          raise StandardError, json
+        end
+      else
+        raise StandardError, json
+      end
+    end
+
+    # @param [RichTextObject, String] to
+    # @return [NotionRubyMapping::RichTextObject] RichTextObject
+    def self.text_object(to)
+      if to.is_a? RichTextObject
+        to
+      else
+        TextObject.new to
+      end
+    end
+
+    # @return [Hash{String (frozen)->Object}]
+    def property_values_json
+      {
+        "type" => @type,
+        @type => partial_property_values_json,
+        "plain_text" => @options["plain_text"],
+        "href" => @options["href"],
+      }.merge annotations_json
+    end
+
+    protected
+
+    # @return [Hash] options
+    attr_reader :options
+
+    # @return [Hash, Hash{String (frozen)->Hash}]
+    def annotations_json
+      annotations = @options.slice(*%w[bold italic strikethrough underline code color])
+      annotations.empty? ? {} : {"annotations" => annotations}
+    end
+  end
+end

data/lib/notion_ruby_mapping/rich_text_property.rb

@@ -1,7 +1,25 @@
 # frozen_string_literal: true
 
 module NotionRubyMapping
+  # RichTextProperty
   class RichTextProperty < TextProperty
     TYPE = "rich_text"
+
+    # @param [Hash] json
+    def update_from_json(json)
+      @will_update = false
+      @text_objects = json["rich_text"].map { |to| RichTextObject.create_from_json to }
+    end
+
+    # @return [Hash] created json
+    def property_values_json
+      text_json = @text_objects.map(&:property_values_json)
+      {
+        @name => {
+          "type" => "rich_text",
+          "rich_text" => text_json.empty? ? (@json || []) : text_json,
+        },
+      }
+    end
   end
 end

data/lib/notion_ruby_mapping/rollup_property.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NotionRubyMapping
+  # Rollup property
+  class RollupProperty < DateBaseProperty
+    include ContainsDoesNotContain
+    include StartsWithEndsWith
+    include GreaterThanLessThan
+    TYPE = "rollup"
+
+    # @param [String] name
+    # @param [Hash] json
+    def initialize(name, json: nil)
+      super name, will_update: false
+      @json = json
+    end
+
+    # @return [Hash] {} created_time cannot be updated
+    def property_values_json
+      {}
+    end
+
+    # @param [Hash] json
+    def update_from_json(json)
+      @will_update = false
+      @json = json["rollup"]
+    end
+  end
+end

data/lib/notion_ruby_mapping/select_property.rb

@@ -10,14 +10,20 @@ module NotionRubyMapping
     # @param [String] name Property name
     # @param [Hash] json
     # @param [String] select String value (optional)
-    def initialize(name, json: nil, select: nil)
-      super(name, json: json)
-      @select = select
+    def initialize(name, will_update: false, json: nil, select: nil)
+      super name, will_update: will_update
+      @select = select || json && json["name"]
+    end
+
+    # @param [Hash] json
+    def update_from_json(json)
+      @will_update = false
+      @select = json["select"]["name"]
     end
 
     # @return [Hash]
-    def create_json
-      {"select" => @select ? {"name" => @select} : @json} || {}
+    def property_values_json
+      {@name => {"type" => "select", "select" => (@select ? {"name" => @select} : @json)}}
     end
 
     # @param [String] select
@@ -27,4 +33,4 @@ module NotionRubyMapping
       @select = select
     end
   end
-end
+end

data/lib/notion_ruby_mapping/text_object.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module NotionRubyMapping
+  # TextObject
+  class TextObject < RichTextObject
+    # @param [String] text
+    # @return [TextObject]
+    def initialize(text, options = {})
+      super "text", {"plain_text" => text}.merge(options)
+      @text = text
+      @type = "text"
+      @will_update = false
+    end
+    attr_reader :text, :will_update
+
+    # @param [String, RichTextObject] value
+    # @return [RichTextObject] self
+    def text=(value)
+      @will_update = true
+      if value.is_a? RichTextObject
+        @options = value.options
+        @text = value.text
+      else
+        p value
+        @text = value
+        @options["plain_text"] = value
+      end
+      self
+    end
+
+    # @param [String, RichTextObject] value
+    # @return [String] input text
+    def plain_text=(value)
+      text(value)
+    end
+
+    # @param [Boolean] flag
+    # @return [Boolean] input flag
+    def bold=(flag)
+      @will_update = true
+      @options["bold"] = flag
+    end
+
+    # @param [Boolean] flag
+    # @return [Boolean] input flag
+    def italic=(flag)
+      @will_update = true
+      @options["italic"] = flag
+    end
+
+    # @param [Boolean] flag
+    # @return [Boolean] input flag
+    def strikethrough=(flag)
+      @will_update = true
+      @options["strikethrough"] = flag
+    end
+
+    # @param [Boolean] flag
+    # @return [Boolean] input flag
+    def underline=(flag)
+      @will_update = true
+      @options["underline"] = flag
+    end
+
+    # @param [Boolean] flag
+    # @return [Boolean] input flag
+    def code=(flag)
+      @will_update = true
+      @options["code"] = flag
+    end
+
+    # @param [String] color
+    # @return [String] input color
+    def color=(color)
+      @will_update = true
+      @options["color"] = color
+    end
+
+    protected
+
+    def partial_property_values_json
+      url = @options["href"]
+      {
+        "content" => @text,
+        "link" => url ? {"url" => url} : nil,
+      }
+    end
+  end
+end

data/lib/notion_ruby_mapping/text_property.rb

@@ -1,11 +1,72 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module NotionRubyMapping
   # Text property
   class TextProperty < Property
+    extend Forwardable
+    include Enumerable
     include EqualsDoesNotEqual
     include ContainsDoesNotContain
     include StartsWithEndsWith
     include IsEmptyIsNotEmpty
+
+    # @param [String] name
+    # @param [Hash] json
+    # @param [Array<RichTextObject>] text_objects
+    def initialize(name, will_update: false, json: nil, text_objects: nil)
+      raise StandardError, "TextObject is abstract class.  Please use RichTextProperty." if instance_of? TextProperty
+
+      super name, will_update: will_update
+      @text_objects = if text_objects
+                        text_objects.map { |to_s| RichTextObject.text_object to_s }
+                      elsif json
+                        json.map { |to| RichTextObject.create_from_json to }
+                      else
+                        []
+                      end
+    end
+    attr_reader :text_objects
+
+    # @return [TrueClass, FalseClass] will update?
+    def will_update
+      @will_update || @text_objects.map(&:will_update).any?
+    end
+
+    # @param [Proc] block
+    # @return [Enumerator]
+    def each(&block)
+      return enum_for(:each) unless block
+
+      @text_objects.each(&block)
+    end
+
+    # @param [String, RichTextObject] to
+    # @return [NotionRubyMapping::RichTextObject] added RichTextObject
+    def <<(to)
+      @will_update = true
+      rto = RichTextObject.text_object(to)
+      @text_objects << rto
+      rto
+    end
+
+    # @param [Numeric] index index number
+    # @return [RichTextObject] selected RichTextObject
+    def [](index)
+      @text_objects[index]
+    end
+
+    # @param [Numeric] index
+    # @return [NotionRubyMapping::RichTextObject] removed RichTextObject
+    def delete_at(index)
+      @will_update = true
+      @text_objects[index]
+    end
+
+    # @return [String] full_text
+    def full_text
+      map(&:text).join ""
+    end
   end
 end

data/lib/notion_ruby_mapping/title_property.rb

@@ -1,7 +1,25 @@
 # frozen_string_literal: true
 
 module NotionRubyMapping
+  # TitleProperty
   class TitleProperty < TextProperty
     TYPE = "title"
+
+    # @param [Hash] json
+    def update_from_json(json)
+      @will_update = false
+      @text_objects = json["title"].map { |to| RichTextObject.create_from_json to }
+    end
+
+    # @return [Hash] created json
+    def property_values_json
+      text_json = map(&:property_values_json)
+      {
+        @name => {
+          "type" => "title",
+          "title" => text_json.empty? ? @json : text_json,
+        },
+      }
+    end
   end
 end