openxml-package 0.2.9 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c894c5ccef5327f4463ca9ddd3401bc6f3aa7e27
-  data.tar.gz: c34eb930e46eff3af421c9ac49bf0bedc78113d6
+SHA256:
+  metadata.gz: 7679189d1fa0249404f348c35516577f71094f29154a4d6db8d18d73a69c0890
+  data.tar.gz: a1a41c6458d7b4f6a90f29443b5778b61e74a44c9ce6a1e5fed2138077b6c2a7
 SHA512:
-  metadata.gz: 2e6418b2b1dadf17009690fbfc6ada8d12f3e5b31493d4df9299bff672b8756098bb11d32c5fb9d3fe59180c7ee2838cf77ac167ca49b9ba6fe3120988cf3749
-  data.tar.gz: f2a422bb660b761956f6a76ec856697115cc0d9ecd08b8f138c6e4093a6a74a8e83d5e2fad8325f62fda30eb6ab88f7f767b5acaa31e976e2bc231774f353cc5
+  metadata.gz: 8b739a383caa59890a27b389d020de3262d7017c3444ee49309b766eb211a1c67ce2c48e94fff0836c1f65b99193f5da6d13261555d5bf0a51b433d470d701b9
+  data.tar.gz: 2a78d1af5bce4eb2bdeb8ce20a2787070094b0590a5fa20ddf299a2b0650fb798ebf2e058ef493825b8807207b4e9d2946ea37a8930c5075912c3eeb4f12223f

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 0.3.4 - Oct 16, 2019
+
+ - Removed rubyzip lock
+
+
+## 0.3.3 - Oct 2, 2018
+
+ - Optimized setting attributes

data/lib/openxml-package/version.rb

@@ -1,3 +1,3 @@
 module OpenXmlPackage
-  VERSION = "0.2.9"
+  VERSION = "0.3.4"
 end

data/lib/openxml/builder.rb

@@ -13,6 +13,7 @@ module OpenXml
     def initialize(options={})
       @to_s_options = { with_xml: true }
 
+      @ns = nil
       @document = Ox::Document.new(
         encoding: "UTF-8",
         version: "1.0",

data/lib/openxml/builder/element.rb

@@ -8,7 +8,7 @@ module OpenXml
       end
 
       def []=(attribute, value)
-        namespace_def = attribute.downcase.to_s.match /^xmlns(?:\:(?<prefix>.*))?$/
+        namespace_def = attribute.downcase.to_s.match(/^xmlns(?:\:(?<prefix>.*))?$/)
         namespaces << namespace_def[:prefix].to_sym if namespace_def && namespace_def[:prefix]
         super
       end

data/lib/openxml/contains_properties.rb

@@ -0,0 +1,29 @@
+require "openxml/has_properties"
+
+module OpenXml
+  module ContainsProperties
+
+    def self.included(base)
+      base.class_eval do
+        include HasProperties
+        include InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+
+      def property_xml(xml)
+        ensure_required_choices
+        props = active_properties
+        return unless render_properties? props
+        props.each { |prop| prop.to_xml(xml) }
+      end
+
+      def properties_attributes
+        {}
+      end
+
+    end
+
+  end
+end

data/lib/openxml/element.rb

@@ -6,21 +6,20 @@ module OpenXml
 
     class << self
       attr_reader :property_name
-      attr_reader :namespace
 
       def tag(*args)
         @tag = args.first if args.any?
-        @tag
+        @tag ||= nil
       end
 
       def name(*args)
         @property_name = args.first if args.any?
-        @name
+        @property_name ||= nil
       end
 
       def namespace(*args)
         @namespace = args.first if args.any?
-        @namespace
+        @namespace ||= nil
       end
 
     end

data/lib/openxml/has_attributes.rb

@@ -1,3 +1,5 @@
+require "openxml/unmet_requirement"
+
 module OpenXml
   module HasAttributes
 
@@ -6,9 +8,13 @@ module OpenXml
     end
 
     module ClassMethods
-      def attribute(name, expects: nil, one_of: nil, in_range: nil, displays_as: nil, namespace: nil, matches: nil, deprecated: false)
-        bad_names = %w(tag name namespace properties_tag)
-        raise ArgumentError if bad_names.member? name
+
+      RESERVED_NAMES = %w{ tag name namespace properties_tag }.freeze
+
+      def attribute(name, expects: nil, one_of: nil, in_range: nil, displays_as: nil, namespace: nil, matches: nil, validation: nil, required: false, deprecated: false)
+        raise ArgumentError if RESERVED_NAMES.member? name.to_s
+
+        required_attributes.push(name) if required
 
         attr_reader name
 
@@ -17,21 +23,39 @@ module OpenXml
           send(expects, value) unless expects.nil?
           matches?(value, matches) unless matches.nil?
           in_range?(value, in_range) unless in_range.nil?
+          validation.call(value) if validation.respond_to? :call
           instance_variable_set "@#{name}", value
         end
 
         camelized_name = name.to_s.gsub(/_([a-z])/i) { $1.upcase }.to_sym
-        attributes[name] = [displays_as || camelized_name, namespace || @attribute_namespace]
+        attributes[name] = [displays_as || camelized_name, namespace || attribute_namespace]
       end
 
       def attributes
-        @attributes ||= {}
+        @attributes ||= {}.tap do |attrs|
+          if superclass.respond_to?(:attributes)
+            superclass.attributes.each do |key, value|
+              attrs[key] = value.dup
+            end
+          end
+        end
+      end
+
+      def required_attributes
+        @required_attributes ||= [].tap do |attrs|
+          attrs.push(*superclass.required_attributes) if superclass.respond_to?(:required_attributes)
+        end
       end
 
       def with_namespace(namespace, &block)
         @attribute_namespace = namespace
         instance_eval(&block)
       end
+
+      def attribute_namespace
+        @attribute_namespace ||= nil
+      end
+
     end
 
     def render?
@@ -42,85 +66,104 @@ module OpenXml
       self.class.attributes
     end
 
+    def required_attributes
+      self.class.required_attributes
+    end
+
   private
 
     def xml_attributes
+      ensure_required_attributes_set
       attributes.each_with_object({}) do |(name, options), attrs|
         display, namespace = options
         value = send(name)
         attr_name = "#{namespace}:#{display}"
-        attr_name = "#{display}" if namespace.nil?
+        attr_name = display.to_s if namespace.nil?
         attrs[attr_name] = value unless value.nil?
       end
     end
 
+    def ensure_required_attributes_set
+      unset_attributes = required_attributes.reject do |attr|
+        instance_variable_defined?("@#{attr}")
+      end
+      return if unset_attributes.empty?
+
+      raise OpenXml::UnmetRequirementError, "Required attribute(s) #{unset_attributes.join(", ")} have not been set"
+    end
+
     def boolean(value)
-      message = "Invalid #{name}: frame must be true or false"
-      raise ArgumentError, message unless [true, false].member? value
+      return if [true, false].member? value
+      raise ArgumentError, "Invalid #{name}: frame must be true or false"
     end
 
     def hex_color(value)
-      message = "Invalid #{name}: must be :auto or a hex color, e.g. 4F1B8C"
-      raise ArgumentError, message unless value == :auto || value =~ /^[0-9A-F]{6}$/
+      return if value == :auto || value =~ /^[0-9A-F]{6}$/
+      raise ArgumentError, "Invalid #{name}: must be :auto or a hex color, e.g. 4F1B8C"
     end
 
     def hex_digit(value)
-      message = "Invalid #{name}: must be a two-digit hex number, e.g. BF"
-      raise ArgumentError, message unless value =~ /^[0-9A-F]{2}$/
+      return if value =~ /^[0-9A-F]{2}$/
+      raise ArgumentError, "Invalid #{name}: must be a two-digit hex number, e.g. BF"
     end
 
     def hex_digit_4(value)
-      message = "Invalid #{name}: must be a four-digit hex number, e.g. BF12"
-      raise ArgumentError, message unless value =~ /^[0-9A-F]{4}$/
+      return if value =~ /^[0-9A-F]{4}$/
+      raise ArgumentError, "Invalid #{name}: must be a four-digit hex number, e.g. BF12"
     end
 
     def long_hex_number(value)
-      message = "Invalid #{name}: must be an eight-digit hex number, e.g., FFAC0013"
-      raise ArgumentError, message unless value =~ /^[0-9A-F]{8}$/
+      return if value =~ /^[0-9A-F]{8}$/
+      raise ArgumentError, "Invalid #{name}: must be an eight-digit hex number, e.g., FFAC0013"
     end
 
     def hex_string(value)
-      message = "Invalid #{name}: must be a string of hexadecimal numbers, e.g. FFA23C6E"
-      raise ArgumentError, message unless value =~ /^[0-9A-F]+$/
+      return if value =~ /^[0-9A-F]+$/
+      raise ArgumentError, "Invalid #{name}: must be a string of hexadecimal numbers, e.g. FFA23C6E"
     end
 
     def integer(value)
-      message = "Invalid #{name}: must be an integer"
-      raise ArgumentError, message unless value.is_a?(Integer)
+      return if value.is_a?(Integer)
+      raise ArgumentError, "Invalid #{name}: must be an integer"
     end
 
     def positive_integer(value)
-      message = "Invalid #{name}: must be a positive integer"
-      raise ArgumentError, message unless value.is_a?(Integer) && value >= 0
+      return if value.is_a?(Integer) && value >= 0
+      raise ArgumentError, "Invalid #{name}: must be a positive integer"
     end
 
     def string(value)
-      message = "Invalid #{name}: must be a string"
-      raise ArgumentError, message if !value.is_a?(String) || value.length.zero?
+      return if value.is_a?(String) && value.length > 0
+      raise ArgumentError, "Invalid #{name}: must be a string"
+    end
+
+    def string_or_blank(value)
+      return if value.is_a?(String)
+      raise ArgumentError, "Invalid #{name}: must be a string, even if the string is empty"
     end
 
     def in_range?(value, range)
-      message = "Invalid #{name}: must be a number between #{range.begin} and #{range.end}"
-      raise ArgumentError, message unless range.include?(value.to_i)
+      return if range.include?(value.to_i)
+      raise ArgumentError, "Invalid #{name}: must be a number between #{range.begin} and #{range.end}"
     end
 
     def percentage(value)
-      message = "Invalid #{name}: must be a percentage"
-      raise ArgumentError, message unless value.is_a?(String) && value =~ /-?[0-9]+(\.[0-9]+)?%/ # Regex supplied in sec. 22.9.2.9 of Office Open XML docs
+      return if value.is_a?(String) && value =~ /-?[0-9]+(\.[0-9]+)?%/ # Regex supplied in sec. 22.9.2.9 of Office Open XML docs
+      raise ArgumentError, "Invalid #{name}: must be a percentage"
     end
 
     def on_or_off(value)
-      valid_in? value, [:on, :off]
+      valid_in? value, %i{ on off }
     end
 
     def valid_in?(value, list)
-      message = "Invalid #{name}: must be one of #{list} (was #{value.inspect})"
-      raise ArgumentError, message unless list.member?(value)
+      return if list.member?(value)
+      raise ArgumentError, "Invalid #{name}: must be one of #{list} (was #{value.inspect})"
     end
 
     def matches?(value, regexp)
-      message = "Value does not match #{regexp}"
-      raise ArgumentError, message unless value =~ regexp
+      return if value =~ regexp
+      raise ArgumentError, "Value does not match #{regexp}"
     end
 
   end

data/lib/openxml/has_children.rb

@@ -2,7 +2,8 @@ module OpenXml
   module HasChildren
     attr_reader :children
 
-    def initialize
+    def initialize(*)
+      super
       @children = []
     end
 
@@ -26,5 +27,6 @@ module OpenXml
     def render?
       super || children.any?
     end
+
   end
 end

data/lib/openxml/has_properties.rb

@@ -0,0 +1,223 @@
+require "openxml/unmet_requirement"
+
+module OpenXml
+  module HasProperties
+
+    class ChoiceGroupUniqueError < RuntimeError; end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def properties_tag(*args)
+        @properties_tag = args.first if args.any?
+        @properties_tag ||= nil
+      end
+
+      def value_property(name, as: nil, klass: nil, required: false, default_value: nil)
+        attr_reader name
+
+        properties[name] = (as || name).to_s
+        required_properties[name] = default_value if required
+        classified_name = properties[name].split("_").map(&:capitalize).join
+        class_name = klass.to_s unless klass.nil?
+        class_name ||= (to_s.split("::")[0...-2] + ["Properties", classified_name]).join("::")
+
+        (choice_groups[current_group] ||= []).push(name) unless current_group.nil?
+
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          group_index = #{@current_group.inspect}
+          ensure_unique_in_group(:#{name}, group_index) unless group_index.nil?
+          instance_variable_set "@#{name}", #{class_name}.new(value)
+        end
+        CODE
+      end
+
+      def property(name, as: nil, klass: nil, required: false)
+        properties[name] = (as || name).to_s
+        required_properties[name] = true if required
+        classified_name = properties[name].split("_").map(&:capitalize).join
+        class_name = klass.to_s unless klass.nil?
+        class_name ||= (to_s.split("::")[0...-2] + ["Properties", classified_name]).join("::")
+
+        (choice_groups[current_group] ||= []).push(name) unless current_group.nil?
+
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}(*args)
+          unless instance_variable_defined?("@#{name}")
+            group_index = #{@current_group.inspect}
+            ensure_unique_in_group(:#{name}, group_index) unless group_index.nil?
+            instance_variable_set "@#{name}", #{class_name}.new(*args)
+          end
+
+          instance_variable_get "@#{name}"
+        end
+        CODE
+      end
+
+      def property_choice(required: false)
+        @current_group = choice_groups.length
+        required_choices << @current_group if required
+        yield
+        @current_group = nil
+      end
+
+      def current_group
+        @current_group ||= nil
+      end
+
+      def properties
+        @properties ||= {}.tap do |props|
+          props.merge!(superclass.properties) if superclass.respond_to?(:properties)
+        end
+      end
+
+      def choice_groups
+        @choice_groups ||= [].tap do |choices|
+          choices.push(*superclass.choice_groups.map(&:dup)) if superclass.respond_to?(:choice_groups)
+        end
+      end
+
+      def required_properties
+        @required_properties ||= {}.tap do |props|
+          props.merge!(superclass.required_properties) if superclass.respond_to?(:required_properties)
+        end
+      end
+
+      def required_choices
+        @required_choices ||= [].tap do |choices|
+          choices.push(*superclass.required_choices) if superclass.respond_to?(:required_choices)
+        end
+      end
+
+      def properties_attribute(name, **args)
+        properties_element.attribute name, **args
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            properties_element.#{name} = value
+          end
+
+          def #{name}
+            properties_element.#{name}
+          end
+        RUBY
+      end
+
+      def properties_element
+        this = self
+        parent_klass = superclass.respond_to?(:properties_element) ? superclass.properties_element : OpenXml::Element
+        @properties_element ||= Class.new(parent_klass) do
+          tag :"#{this.properties_tag || this.default_properties_tag}"
+          namespace :"#{this.namespace}"
+        end
+      end
+
+      def default_properties_tag
+        :"#{tag}Pr"
+      end
+
+    end
+
+    def initialize(*_args)
+      super
+      build_required_properties
+    end
+
+    def properties_element
+      @properties_element ||= self.class.properties_element.new
+    end
+
+    def properties_attributes
+      properties_element.attributes
+    end
+
+    def render?
+      return true unless defined?(super)
+      render_properties? || super
+    end
+
+    def to_xml(xml)
+      super(xml) do
+        property_xml(xml)
+        yield xml if block_given?
+      end
+    end
+
+    def property_xml(xml)
+      ensure_required_choices
+      props = active_properties
+      return unless render_properties? props
+
+      properties_element.to_xml(xml) do
+        props.each { |prop| prop.to_xml(xml) }
+      end
+    end
+
+    def build_required_properties
+      required_properties.each do |prop, default_value|
+        public_send(:"#{prop}=", default_value) if respond_to? :"#{prop}="
+        public_send(:"#{prop}")
+      end
+    end
+
+  private
+
+    def properties
+      self.class.properties
+    end
+
+    def active_properties
+      properties.keys.map { |property| instance_variable_get("@#{property}") }.compact
+    end
+
+    def render_properties?(properties=active_properties)
+      properties.any?(&:render?) || properties_attributes.keys.any? do |key|
+        properties_element.instance_variable_defined?("@#{key}")
+      end
+    end
+
+    def properties_tag
+      self.class.properties_tag || default_properties_tag
+    end
+
+    def default_properties_tag
+      :"#{tag}Pr"
+    end
+
+    def choice_groups
+      self.class.choice_groups
+    end
+
+    def required_properties
+      self.class.required_properties
+    end
+
+    def required_choices
+      self.class.required_choices
+    end
+
+    def ensure_unique_in_group(name, group_index)
+      other_names = (choice_groups[group_index] - [name])
+      return if other_names.none? { |other_name| instance_variable_defined?("@#{other_name}") }
+      raise ChoiceGroupUniqueError, "Property #{name} cannot also be set with #{other_names.join(", ")}."
+    end
+
+    def unmet_choices
+      required_choices.reject do |choice_index|
+        choice_groups[choice_index].one? do |prop_name|
+          instance_variable_defined?("@#{prop_name}")
+        end
+      end
+    end
+
+    def ensure_required_choices
+      unmet_choice_groups = unmet_choices.map { |index| choice_groups[index].join(", ") }
+      return if unmet_choice_groups.empty?
+      raise OpenXml::UnmetRequirementError, "Required choice from among group(s) (#{unmet_choice_groups.join("), (")}) not made"
+    end
+
+  end
+end

data/lib/openxml/package.rb

@@ -18,7 +18,7 @@ module OpenXml
       end
 
       def content_types(&block)
-        content_types_presets.instance_eval &block
+        content_types_presets.instance_eval(&block)
       end
 
       def open(path)
@@ -80,7 +80,7 @@ module OpenXml
     end
 
     def write_to(path)
-      File.open(path, "w") do |file|
+      File.open(path, "wb") do |file|
         file.write to_stream.string
       end
     end

data/lib/openxml/parts/content_types.rb

@@ -40,7 +40,7 @@ module OpenXml
       end
 
       def to_xml
-        build_xml do |xml|
+        build_standalone_xml do |xml|
           xml.Types(xmlns: "http://schemas.openxmlformats.org/package/2006/content-types") {
             defaults.each { |extension, content_type| xml.Default("Extension" => extension, "ContentType" => content_type) }
             overrides.each { |part_name, content_type| xml.Override("PartName" => part_name, "ContentType" => content_type) }

data/lib/openxml/parts/rels.rb

@@ -23,7 +23,7 @@ module OpenXml
         end
       end
 
-      def add_relationship(type, target, id=nil, target_mode=nil)
+      def add_relationship(type, target, id=next_id, target_mode=nil)
         OpenXml::Elements::Relationship.new(type, target, id, target_mode).tap do |relationship|
           relationships.push relationship
         end
@@ -56,6 +56,11 @@ module OpenXml
     private
       attr_reader :relationships
 
+      def next_id
+        @current_id = (@current_id || 0) + 1
+        "rId#{@current_id}"
+      end
+
     end
   end
 end

data/lib/openxml/properties.rb

@@ -0,0 +1,22 @@
+module OpenXml
+  module Properties
+  end
+end
+
+require "openxml/properties/base_property"
+require "openxml/properties/complex_property"
+require "openxml/properties/value_property"
+
+require "openxml/properties/boolean_property"
+require "openxml/properties/integer_property"
+require "openxml/properties/positive_integer_property"
+require "openxml/properties/string_property"
+require "openxml/properties/on_off_property"
+require "openxml/properties/toggle_property"
+
+require "openxml/properties/container_property"
+require "openxml/properties/transparent_container_property"
+
+Dir.glob(File.join(File.dirname(__FILE__), "properties", "*.rb").to_s).each do |file|
+  require file
+end

data/lib/openxml/properties/base_property.rb

@@ -0,0 +1,80 @@
+module OpenXml
+  module Properties
+    class BaseProperty
+      attr_reader :value
+
+      class << self
+        attr_reader :property_name
+        attr_reader :allowed_tags
+
+        def tag_is_one_of(tags)
+          attr_accessor :tag
+          @allowed_tags = tags
+        end
+
+        def tag(*args)
+          @tag = args.first if args.any?
+          @tag ||= nil
+        end
+
+        def name(*args)
+          @property_name = args.first if args.any?
+          @property_name ||= nil
+        end
+
+        def namespace(*args)
+          @namespace = args.first if args.any?
+          @namespace ||= nil
+        end
+
+      end
+
+      def initialize(tag=nil, *_args)
+        return unless self.class.allowed_tags
+        validate_tag tag
+        @tag = tag
+      end
+
+      def validate_tag(tag)
+        return if self.class.allowed_tags.include?(tag)
+        allowed = self.class.allowed_tags.join(", ")
+        raise ArgumentError, "Invalid tag name for #{name}: #{tag.inspect}. It should be one of #{allowed}."
+      end
+
+      def render?
+        !value.nil?
+      end
+
+      def name
+        self.class.property_name || default_name
+      end
+
+      def default_name
+        class_name.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      end
+
+      def tag
+        self.class.tag || default_tag
+      end
+
+      def default_tag
+        (class_name[0, 1].downcase + class_name[1..-1]).to_sym
+      end
+
+      def namespace
+        self.class.namespace
+      end
+
+    private
+
+      def apply_namespace(xml)
+        namespace.nil? ? xml : xml[namespace]
+      end
+
+      def class_name
+        self.class.to_s.split(/::/).last
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/boolean_property.rb

@@ -0,0 +1,15 @@
+module OpenXml
+  module Properties
+    class BooleanProperty < ValueProperty
+
+      def ok_values
+        [nil, true, false]
+      end
+
+      def to_xml(xml)
+        super if value
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/complex_property.rb

@@ -0,0 +1,21 @@
+require "openxml/has_attributes"
+
+module OpenXml
+  module Properties
+    class ComplexProperty < BaseProperty
+      include HasAttributes
+
+      def to_xml(xml)
+        return unless render?
+        apply_namespace(xml).public_send(tag, xml_attributes) do
+          yield xml if block_given?
+        end
+      end
+
+      def render?
+        !xml_attributes.empty?
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/container_property.rb

@@ -0,0 +1,70 @@
+require "openxml/has_attributes"
+
+module OpenXml
+  module Properties
+    class ContainerProperty < BaseProperty
+      include Enumerable
+      include HasAttributes
+
+      class << self
+
+        def child_class(*args)
+          unless args.empty?
+            @child_classes = args.map { |arg|
+              prop_name = arg.to_s.split(/_/).map(&:capitalize).join # LazyCamelCase
+              const_name = (self.to_s.split(/::/)[0...-1] + [prop_name]).join("::")
+              Object.const_get const_name
+            }
+          end
+
+          @child_classes
+        end
+        alias child_classes child_class
+
+      end
+
+      def initialize
+        @children = []
+      end
+
+      def <<(child)
+        raise ArgumentError, invalid_child_message unless valid_child?(child)
+        children << child
+      end
+
+      def each(*args, &block)
+        children.each(*args, &block)
+      end
+
+      def render?
+        !children.length.zero?
+      end
+
+      def to_xml(xml)
+        return unless render?
+
+        apply_namespace(xml).public_send(tag, xml_attributes) {
+          each { |child| child.to_xml(xml) }
+        }
+      end
+
+    private
+
+      attr_reader :children
+
+      def invalid_child_message
+        class_name = self.class.to_s.split(/::/).last
+        "#{class_name} must be instances of one of the following: #{child_classes}"
+      end
+
+      def valid_child?(child)
+        child_classes.any? { |child_class| child.is_a?(child_class) }
+      end
+
+      def child_classes
+        self.class.child_classes
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/integer_property.rb

@@ -0,0 +1,15 @@
+module OpenXml
+  module Properties
+    class IntegerProperty < ValueProperty
+
+      def valid?
+        value.is_a? Integer
+      end
+
+      def invalid_message
+        "Invalid #{name}: must be an integer"
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/on_off_property.rb

@@ -0,0 +1,21 @@
+module OpenXml
+  module Properties
+    class OnOffProperty < ValueProperty
+
+      def ok_values
+        [true, false, :on, :off] # :on and :off are from the Transitional Spec
+      end
+
+      def to_xml(xml)
+        if value == true
+          apply_namespace(xml).public_send(tag) do
+            yield xml if block_given?
+          end
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/positive_integer_property.rb

@@ -0,0 +1,15 @@
+module OpenXml
+  module Properties
+    class PositiveIntegerProperty < IntegerProperty
+
+      def valid?
+        super && value >= 0
+      end
+
+      def invalid_message
+        "Invalid #{name}: must be a positive integer"
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/string_property.rb

@@ -0,0 +1,15 @@
+module OpenXml
+  module Properties
+    class StringProperty < ValueProperty
+
+      def valid?
+        value.is_a?(String) && !value.length.zero?
+      end
+
+      def invalid_message
+        "Invalid value for #{name}; string expected (provided: #{value.inspect})"
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/toggle_property.rb

@@ -0,0 +1,11 @@
+module OpenXml
+  module Properties
+    class ToggleProperty < OnOffProperty
+      # Toggle properties are no different in representation than on/off properties;
+      # rather, the difference is in how they compose with one another (cf.
+      # Section 17.7.3). It's helpful, then, to retain the concept, but entirely
+      # unnecessary to duplicate implementation.
+      # cf. Section A.6.9 of the spec, and Section A.7.9 of the transitional spec.
+    end
+  end
+end

data/lib/openxml/properties/transparent_container_property.rb

@@ -0,0 +1,12 @@
+module OpenXml
+  module Properties
+    class TransparentContainerProperty < ContainerProperty
+
+      def to_xml(xml)
+        return unless render?
+        each { |child| child.to_xml(xml) }
+      end
+
+    end
+  end
+end

data/lib/openxml/properties/value_property.rb

@@ -0,0 +1,37 @@
+module OpenXml
+  module Properties
+    class ValueProperty < BaseProperty
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        raise ArgumentError, invalid_message unless valid?
+      end
+
+      def valid?
+        ok_values.member? value
+      end
+
+      def invalid_message
+        "#{value.inspect} is an invalid value for #{name}; acceptable: #{ok_values.join(", ")}"
+      end
+
+      def render?
+        !value.nil?
+      end
+
+      def to_xml(xml)
+        apply_namespace(xml).public_send(tag, :"#{value_attribute}" => value) do
+          yield xml if block_given?
+        end
+      end
+
+    private
+
+      def value_attribute
+        namespace.nil? ? "val" : "#{namespace}:val"
+      end
+
+    end
+  end
+end

data/lib/openxml/render_when_empty.rb

@@ -0,0 +1,9 @@
+module OpenXml
+  module RenderWhenEmpty
+
+    def render?
+      true
+    end
+
+  end
+end

data/lib/openxml/rubyzip_fix.rb

@@ -4,10 +4,12 @@ module Zip
   class InputStream
   protected
 
+    alias _old_get_io get_io
+
     # The problem in RubyZip 1.1.0 is that we only call `seek`
     # when `io` is a File. We need to move the cursor to the
     # right position when `io` is a StringIO as well.
-    def get_io(io, offset = 0)
+    def get_io(io, offset=0)
       io = ::File.open(io, "rb") unless io.is_a?(IO) || io.is_a?(StringIO)
       io.seek(offset, ::IO::SEEK_SET)
       io

data/lib/openxml/unmet_requirement.rb

@@ -0,0 +1,3 @@
+module OpenXml
+  class UnmetRequirementError < RuntimeError; end
+end

data/openxml-package.gemspec

@@ -19,11 +19,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "rubyzip", "~> 1.2.1"
+  spec.add_dependency "rubyzip"
   spec.add_dependency "nokogiri"
   spec.add_dependency "ox"
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: openxml-package
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.4
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2021-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -187,6 +187,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -195,20 +196,36 @@ files:
 - lib/openxml-package/version.rb
 - lib/openxml/builder.rb
 - lib/openxml/builder/element.rb
+- lib/openxml/contains_properties.rb
 - lib/openxml/content_types_presets.rb
 - lib/openxml/element.rb
 - lib/openxml/errors.rb
 - lib/openxml/has_attributes.rb
 - lib/openxml/has_children.rb
+- lib/openxml/has_properties.rb
 - lib/openxml/package.rb
 - lib/openxml/part.rb
 - lib/openxml/parts.rb
 - lib/openxml/parts/content_types.rb
 - lib/openxml/parts/rels.rb
 - lib/openxml/parts/unparsed_part.rb
+- lib/openxml/properties.rb
+- lib/openxml/properties/base_property.rb
+- lib/openxml/properties/boolean_property.rb
+- lib/openxml/properties/complex_property.rb
+- lib/openxml/properties/container_property.rb
+- lib/openxml/properties/integer_property.rb
+- lib/openxml/properties/on_off_property.rb
+- lib/openxml/properties/positive_integer_property.rb
+- lib/openxml/properties/string_property.rb
+- lib/openxml/properties/toggle_property.rb
+- lib/openxml/properties/transparent_container_property.rb
+- lib/openxml/properties/value_property.rb
 - lib/openxml/relationship.rb
+- lib/openxml/render_when_empty.rb
 - lib/openxml/rubyzip_fix.rb
 - lib/openxml/types.rb
+- lib/openxml/unmet_requirement.rb
 - openxml-package.gemspec
 - tmp/.keep
 homepage: https://github.com/openxml/openxml-package
@@ -230,8 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A Ruby implementation of OpenXmlPackage from Microsoft's Open XML SDK