epuber 0.3.5

data/lib/epuber/dsl/attribute_support.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+
+module Epuber
+  module DSL
+    module AttributeSupport
+      # Method to create attribute for DSL object
+      #
+      # @example
+      #     attribute :name
+      #     attribute :title, required: true, inherited: true
+      #
+      # @param name [Symbol] attribute name
+      # @param options [Hash]
+      #
+      # @see Attribute
+      #
+      # @return nil
+      #
+      def attribute(name, options = {})
+        attr = Attribute.new(name, options)
+
+        dsl_attributes[name] = attr
+
+        define_method_attr(name, attr)
+      end
+
+      # All DSL attributes
+      #
+      # @return [Hash<Symbol, Attribute>]
+      #
+      def dsl_attributes
+        @dsl_attributes ||= {}
+      end
+
+      # @return [Object]
+      #
+      def find_root(instance)
+        return unless instance.respond_to?(:parent)
+
+        if instance.parent.nil?
+          instance
+        else
+          find_root(instance.parent)
+        end
+      end
+
+      # @param name [Symbol]
+      # @param attr [Epuber::DSL::Attribute]
+      #
+      # @return nil
+      #
+      def define_method_attr(name, attr)
+        key = name
+
+        # define normal getter
+        define_method(key) do
+          value = @attributes_values[key]
+
+          if !value.nil?
+            # has value -> return it
+            value
+
+          elsif attr.inherited? && respond_to?(:parent) && !parent.nil?
+            # hasn't value –> try to find it in parent
+            parent.send(key)
+
+          elsif !attr.default_value.nil?
+            # write default value on first access to root object
+            root_obj = self.class.find_root(self) || self
+            root_obj.send(attr.writer_name, attr.default_value)
+
+            # and return the default value
+            attr.default_value
+          end
+        end
+
+        # define normal setter
+        define_method(attr.writer_name) do |value|
+          if attr.singularize?
+            array_value = if value.is_a? Array
+                            value
+                          else
+                            [value]
+                          end
+
+            mapped = array_value.map { |one_value| attr.converted_value(one_value) }
+
+            @attributes_values[key] = mapped
+          else
+            begin
+              @attributes_values[key] = attr.converted_value(value)
+            rescue Exception => e
+              UI.warning("Invalid value `#{value}` for attribute `#{name}`, original error `#{e}`", location: caller_locations[1])
+            end
+          end
+        end
+
+        return unless attr.singularize?
+
+        # define singular methods
+        singular_key = key.to_s.singularize.to_sym
+
+        define_method(singular_key) do
+          value = @attributes_values[key]
+
+          if attr.singularize? && value.is_a?(Array)
+            value.first
+          else
+            value
+          end
+        end
+
+        define_method(attr.writer_singular_form) do |value|
+          if attr.singularize?
+            array_value = if value.is_a?(Array)
+                            value
+                          else
+                            [value]
+                          end
+
+            @attributes_values[key] = array_value.map { |one_value| attr.converted_value(one_value) }
+          else
+            @attributes_values[key] = attr.converted_value(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/epuber/dsl/object.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require_relative 'attribute'
+require_relative 'attribute_support'
+
+require 'active_support/core_ext/string/inflections'
+
+
+module Epuber
+  module DSL
+    class Object
+      class ValidationError < StandardError; end
+
+      # @return [String, nil]
+      #
+      attr_reader :file_path
+
+      def initialize
+        super
+        @attributes_values = {}
+        @file_path = nil
+
+        # iterate over all attributes to write default values
+        self.class.dsl_attributes.each do |key, _attr|
+          self.send(key)
+        end
+      end
+
+      # @return [String]
+      #
+      def to_s
+        "<#{self.class} #{@attributes_values}>"
+      end
+
+      # @return nil
+      #
+      def freeze
+        super
+        @attributes_values.freeze
+      end
+
+      # Validates all values of attributes, if there is some error, StandardError will be raised
+      #
+      # @note it only check for required values for now
+      #
+      # @return nil
+      #
+      def validate
+        self.class.dsl_attributes.each do |key, attr|
+          value = @attributes_values[key] || attr.converted_value(attr.default_value)
+
+          attr.validate_type(value)
+
+          next unless attr.required? && value.nil?
+
+          if attr.singularize?
+            raise ValidationError, "missing required attribute `#{key.to_s.singularize}|#{key}`"
+          else
+            raise ValidationError, "missing required attribute `#{key}`"
+          end
+        end
+      end
+
+      # Creates new instance by parsing ruby code from file
+      #
+      # @param file_path [String]
+      #
+      # @return [Self]
+      #
+      def self.from_file(file_path)
+        from_string(::File.new(file_path).read, file_path)
+      end
+
+      # Creates new instance by parsing ruby code from string
+      #
+      # @param string [String]
+      #
+      # @return [Self]
+      #
+      def self.from_string(string, file_path = nil)
+        # rubocop:disable Lint/Eval
+        obj = if file_path
+                eval(string, nil, file_path)
+              else
+                eval(string)
+              end
+        # rubocop:enable Lint/Eval
+
+        unless obj.is_a?(self)
+          msg = "Invalid object #{obj.class}, expected object of class #{self}"
+
+          if file_path
+            msg += ", loaded from file #{file_path}"
+
+          end
+
+          raise StandardError, msg
+        end
+
+        obj.instance_eval { @file_path = file_path }
+        obj
+      end
+
+      # @return [Bool] is created from file
+      #
+      def from_file?
+        !file_path.nil?
+      end
+
+      # --------------------------------------------------- #
+
+      # @group Attributes
+
+      protected
+
+      extend AttributeSupport
+
+      class << self
+        # @return [Hash<Symbol, Attribute>] The attributes of the class.
+        #
+        attr_accessor :attributes
+      end
+
+      # @return [Hash<Symbol, Any>]
+      #
+      attr_accessor :attributes_values
+
+      # Raise exception when there is used some unknown method or attribute
+      #
+      # This is just for creating better message in raised exception
+      #
+      # @return nil
+      #
+      def method_missing(name, *args)
+        if /([^=]+)=?/ =~ name
+          attr_name = $1
+          location = caller_locations.first
+          raise NameError, "Unknown attribute or method `#{attr_name}` for class `#{self.class}` in file `#{location.path}:#{location.lineno}`"
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/epuber/dsl/tree_object.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require_relative 'object'
+
+module Epuber
+  module DSL
+    class TreeObject < Object
+      # @param [TreeObject] parent
+      #
+      def initialize(parent = nil)
+        super()
+
+        @parent      = parent
+        @sub_items = []
+
+        parent.sub_items << self unless parent.nil?
+      end
+
+      # @return nil
+      #
+      def freeze
+        super
+        @sub_items.freeze
+      end
+
+      # @return [self] reference to parent
+      #
+      attr_reader :parent
+
+      # @return [Array<self>] child items
+      #
+      attr_reader :sub_items
+
+      # @return [Array<self>] child items
+      #
+      def flat_sub_items
+        all = []
+
+        sub_items.each do |item|
+          all << item
+          all.concat(item.flat_sub_items)
+        end
+
+        all
+      end
+
+      # @return [Bool] receiver is root
+      #
+      def root?
+        @parent.nil?
+      end
+
+      # @return nil
+      #
+      def validate
+        super
+        sub_items.each(&:validate)
+      end
+
+      class << self
+        # @return [Self]
+        #
+        attr_accessor :current_parent_object
+      end
+
+      # @yield [child_item]
+      # @yieldparam child_item [self] created child item
+      #
+      # @return [self]
+      #
+      def create_child_item(*args)
+        child = self.class.new(*args)
+
+        parent_object_before = self.class.current_parent_object
+
+        child.parent = parent_object_before || self
+        child.parent.sub_items << child
+
+        self.class.current_parent_object = child
+        yield child if block_given?
+
+
+        self.class.current_parent_object = parent_object_before
+
+        child
+      end
+
+      # @return nil
+      #
+      def create_child_items
+        yield self if block_given?
+      end
+
+
+      protected
+
+      attr_writer :parent
+      attr_writer :sub_items
+    end
+  end
+end

data/lib/epuber/helper.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Epuber
+  module Helper
+
+    # @param [Book::TocItem] toc_item
+    # @param [Compiler::FileResolver] file_resolver
+    # @param [String] context_path
+    #
+    # @return [String]
+    #
+    def self.destination_path_for_toc_item(toc_item, file_resolver, context_path)
+      file = file_resolver.file_from_request(toc_item.file_request)
+      path = [file.final_destination_path, toc_item.file_fragment].compact.join('#')
+
+      Pathname.new(path).relative_path_from(Pathname.new(context_path)).to_s
+    end
+  end
+end

data/lib/epuber/lockfile.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'yaml'
+
+
+module Epuber
+  class Lockfile
+    attr_accessor :defined_from_file
+
+    # @param [Hash] data
+    #
+    def initialize(data = {})
+      @internal_data = data
+    end
+
+    # @return [self]
+    #
+    def self.from_file(file_path)
+      if File.exists?(file_path)
+        hash = YAML.load(File.read(file_path))
+      else
+        hash = {}
+      end
+
+      inst = self.new(hash)
+      inst.defined_from_file = file_path
+      inst
+    end
+
+    # @return nil
+    #
+    def write_to_file
+      return if defined_from_file.nil?
+
+      File.open(defined_from_file, 'w') do |f|
+        f.write(YAML.dump(@internal_data))
+      end
+    end
+
+
+    # @return [Epuber::Version]
+    #
+    def version
+      @internal_data['version']
+    end
+
+    # @param [Epuber::Version] new_version
+    #
+    # @return [Epuber::Version]
+    #
+    def version=(new_version)
+      @internal_data['version'] = new_version
+    end
+  end
+end