castaway 1.0.0

data/lib/castaway/production/scenes.rb

@@ -0,0 +1,39 @@
+require 'castaway/scene'
+
+module Castaway
+  class Production
+    module Scenes
+
+      # Returns the duration of the production, in seconds.
+      def duration
+        @scenes.last.finish
+      end
+
+      # Returns the first scene with the given title.
+      def scene(title)
+        @scenes.find { |s| s.title == title }
+      end
+
+      def resource(name)
+        self.class.resource(name)
+      end
+
+      def pointers
+        self.class.pointers
+      end
+
+      def _build_scenes
+        @scenes = self.class.scenes.map do |(name, config)|
+          Castaway::Scene.new(name, self).configure(&config)
+        end
+
+        @scenes = @scenes.sort_by(&:start)
+
+        @scenes.each.with_index do |scene, index|
+          scene.update_from_next(@scenes[index + 1])
+        end
+      end
+
+    end
+  end
+end

data/lib/castaway/range.rb

@@ -0,0 +1,70 @@
+require 'castaway/times'
+
+module Castaway
+
+  class Range
+    include Castaway::Times
+
+    attr_accessor :start_frame, :end_frame
+
+    def self.at_frame(production, frame)
+      new(production).tap do |range|
+        range.start_frame = frame
+        range.end_frame = frame
+      end
+    end
+
+    def self.at_time(production, time)
+      new(production).tap do |range|
+        range.start_time = time
+        range.end_time = time
+      end
+    end
+
+    def self.at_scene(production, title)
+      new(production).tap do |range|
+        range.start_scene = title
+        range.end_scene = title
+      end
+    end
+
+    def initialize(production)
+      @production = production
+      @start_frame = 0
+      self.end_time = production.duration
+    end
+
+    def truncated?
+      start_frame > 0 || end_time < @production.duration
+    end
+
+    def start_time=(t)
+      @start_frame = (_parse_time(t) * @production.fps).floor
+    end
+
+    def start_time
+      @start_frame / @production.fps.to_f
+    end
+
+    def end_time=(t)
+      @end_frame = (_parse_time(t) * @production.fps).ceil
+    end
+
+    def end_time
+      @end_frame / @production.fps.to_f
+    end
+
+    def start_scene=(title)
+      scene = @production.scene(title)
+      raise ArgumentError, "no scene named #{title.inspect}" unless scene
+      self.start_time = scene.start
+    end
+
+    def end_scene=(title)
+      scene = @production.scene(title)
+      raise ArgumentError, "no scene named #{title.inspect}" unless scene
+      self.end_time = scene.finish
+    end
+  end
+
+end

data/lib/castaway/relative_to.rb

@@ -0,0 +1,18 @@
+require 'mini_magick'
+require 'castaway/point'
+
+module Castaway
+  class RelativeTo
+    def initialize(image_file_name, production)
+      path = production.resource(image_file_name)
+      image = MiniMagick::Image.new(path)
+      @width = image.width.to_f
+      @height = image.height.to_f
+      @production = production
+    end
+
+    def position(x, y)
+      Castaway::Point.new(x / @width, y / @height) * @production.resolution
+    end
+  end
+end

data/lib/castaway/scene.rb

@@ -0,0 +1,145 @@
+require 'castaway/element/matte'
+require 'castaway/element/still'
+require 'castaway/element/pointer'
+require 'castaway/element/text'
+require 'castaway/relative_to'
+require 'castaway/times'
+
+module Castaway
+  class Scene
+    include Castaway::Times
+
+    attr_reader :title
+    attr_reader :production
+
+    attr_reader :finish, :duration
+
+    attr_reader :_timeline
+
+    def initialize(title, production)
+      @title = title
+      @production = production
+    end
+
+    def configure(&block)
+      instance_eval(&block)
+      self
+    end
+
+    # Declares (or returns) the time value (in seconds) for the start of this
+    # scene. Any value parsable by Castaway::Times will be accepted.
+    def start(value = nil)
+      return @start unless value
+      @start = _parse_time(value)
+    end
+
+    # Parses and returns the seconds corresponding to the given value. See
+    # Castaway::Times.
+    def time(value)
+      _parse_time(value)
+    end
+
+    # Returns a new Castaway::RelativeTo instance for the resource with the
+    # given file name. This is useful for positioning pointers in a
+    # resolution-independent way.
+    def relative_to_image(name)
+      RelativeTo.new(name, production)
+    end
+
+    # Sets (or returns) the script corresponding to the current scene.
+    # This is not used, except informationally.
+    def script(*args)
+      if args.empty?
+        @script
+      elsif args.length == 1
+        @script = _strip(args.first)
+      else
+        raise ArgumentError, 'script expects 0 or 1 argument'
+      end
+    end
+
+    # Declare the plan to be used for constructing the scene. Within the plan,
+    # scene elements are declared and configured.
+    #
+    #     plan do
+    #       matte(:black).enter(-0.5).in(:dissolve, speed: 0.5)
+    #     end
+    #
+    # See #matte, #still, #text, #sprite, and #pointer.
+    def plan(&block)
+      @plan = block
+    end
+
+    def construct(timeline)
+      @_timeline = timeline
+      instance_eval(&@plan) if @plan
+    ensure
+      remove_instance_variable :@_timeline
+    end
+
+    # Returns a new Castaway::Element::Matte element with the given color, and
+    # adds it to the timeline.
+    def matte(color)
+      Element::Matte.new(production, self, color).tap do |element|
+        _timeline.add(element)
+      end
+    end
+
+    # Returns a new Castaway::Element::Still element for the given filename,
+    # and adds it to the timeline. It will be forced to fill the entire frame.
+    def still(filename)
+      _still(filename, true)
+    end
+
+    # Returns a new Castaway::Element::Still element for the given filename,
+    # and adds it to the timeline. It's native dimensions will be preserved.
+    def sprite(filename)
+      _still(filename, false)
+    end
+
+    # Returns a new Castaway::Element::Pointer element and adds it to the
+    # timeline. If an `id` is given, the pointer declared with that `id` is
+    # used.
+    def pointer(id = :default)
+      Element::Pointer.new(production, self, id).tap do |pointer|
+        _timeline.add(pointer)
+      end
+    end
+
+    # Returns a new Castaway::Element::Text element with the given text, and
+    # adds it to the timeline.
+    def text(string)
+      Element::Text.new(production, self, string).tap do |text|
+        _timeline.add(text)
+      end
+    end
+
+    # Returns a Castaway::Point with the given coordinates multiplied by the
+    # resolution. This let's you declare coordinates as fractions of the frame
+    # size, so that they work regardless of the final rendered resolution.
+    def relative_position(x, y)
+      Castaway::Point.new(x, y) * production.resolution
+    end
+
+    def update_from_next(neighbor)
+      @finish = neighbor.nil? ? @start : neighbor.start
+      @duration = @finish - @start
+    end
+
+    def _still(filename, full)
+      Element::Still.new(production, self, filename, full: full).
+        tap do |element|
+          _timeline.add(element)
+        end
+    end
+
+    def _strip(text)
+      if text =~ /^(\s+)\S/
+        indent = Regexp.last_match(1)
+        text.gsub(/^#{indent}/, '')
+      else
+        text
+      end
+    end
+  end
+end

data/lib/castaway/size.rb

@@ -0,0 +1,47 @@
+module Castaway
+
+  class Size < Struct.new(:width, :height)
+    def *(factor)
+      if factor.is_a?(Size)
+        Size.new(width * factor.width, height * factor.height)
+      else
+        Size.new(width * factor, height * factor)
+      end
+    end
+
+    def present?
+      width || height
+    end
+
+    def empty?
+      (width || 0).zero? && (height || 0).zero?
+    end
+
+    def aspect_ratio
+      @aspect_ratio ||= width.to_f / height
+    end
+
+    def with_height(height)
+      Size.new((aspect_ratio * height).to_i, height.to_i)
+    end
+
+    def with_width(width)
+      Size.new(width.to_i, (width / aspect_ratio).to_i)
+    end
+
+    def to_s
+      format('(%.2f, %.2f)', width, height)
+    end
+
+    def to_geometry
+      format('%.2fx%.2f', width, height).tap do |geometry|
+        geometry << '!' if width && height
+      end
+    end
+
+    def to_resolution
+      format('%dx%d', width || 0, height || 0)
+    end
+  end
+
+end

data/lib/castaway/timeline.rb

@@ -0,0 +1,80 @@
+require 'logger'
+require 'fileutils'
+
+module Castaway
+
+  class Timeline
+    attr_reader :resolution, :fps
+
+    def initialize(resolution, fps)
+      @resolution = resolution
+      @elements = []
+      @fps = fps
+
+      @cached_command = nil
+      @cached_file = nil
+    end
+
+    def add(element)
+      @elements << element
+    end
+
+    def duration
+      @elements.map(&:t2).max
+    end
+
+    def render_frame(frame, name: 'frame')
+      t = frame / fps.to_f
+
+      signature = nil
+      tool = MiniMagick::Tool::Convert.new.tap do |convert|
+        convert << '-size' << resolution.to_geometry
+        convert.xc 'black'
+
+        @elements.sort_by(&:t1).each do |element|
+          next unless element.alive_at?(t)
+          element.render_at(t, convert)
+        end
+
+        convert.colorspace 'sRGB'
+        convert.type 'TrueColor'
+        convert.depth '16'
+
+        signature = convert.command
+        convert << "PNG48:#{name}.png"
+      end
+
+      if signature != @cached_command
+        _log frame, t, tool.command.join(' ')
+        @cached_command = signature
+        @cached_file = name
+        tool.call
+      else
+        old = "#{@cached_file}.png"
+        new = "#{name}.png"
+        _log frame, t, "duplicate #{old} as #{new}"
+        _link old, new
+      end
+    end
+
+    def _link(old, new)
+      # FIXME: detect whether linking is supported, and fallback to copy
+      # if not.
+
+      FileUtils.ln(old, new)
+    end
+
+    def _logger
+      @_logger ||= Logger.new('build.log').tap do |logger|
+        logger.formatter = lambda do |severity, _datetime, _progname, msg|
+          "#{severity}: #{msg}\n"
+        end
+      end
+    end
+
+    def _log(frame, t, msg)
+      _logger.info { format('[%d:%.2fs] %s', frame, t, msg) }
+    end
+  end
+
+end

data/lib/castaway/times.rb

@@ -0,0 +1,33 @@
+module Castaway
+  module Times
+    def _parse_time(spec)
+      _parse_numeric_time(spec) ||
+        _parse_timespec_time(spec) ||
+        raise(ArgumentError, "unsupported time #{spec.inspect}")
+    end
+
+    def _parse_numeric_time(spec)
+      if spec.is_a?(Numeric)
+        spec
+      elsif spec =~ /^\d+(\.\d+)?s?$/
+        spec.to_f
+      end
+    end
+
+    def _parse_timespec_time(spec)
+      return unless spec =~ /^(\d+)(?::(\d+))?(?::(\d+))?(\.\d+)?$/
+
+      a = Regexp.last_match(1)
+      b = Regexp.last_match(2)
+      c = Regexp.last_match(3)
+      d = Regexp.last_match(4)
+
+      time = [c, b, a].compact.each.with_index.reduce(0) do |m, (v, i)|
+        m + v.to_i * 60**i
+      end
+
+      time += d.to_f if d
+      time
+    end
+  end
+end

data/lib/castaway/version.rb

@@ -0,0 +1,3 @@
+module Castaway
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: castaway
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamis Buck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: chaussettes
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |2
+      Construct screencasts in Ruby! Write your script, declare your timeline,
+      mix your audio, and render your video in an easily-edited, easily-repeated
+      DSL. (Depends on ImageMagick, Sox, and FFMPEG for the heavy-lifting.)
+email:
+- jamis@jamisbuck.org
+executables:
+- castaway
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- bin/castaway
+- lib/castaway.rb
+- lib/castaway/animation.rb
+- lib/castaway/box.rb
+- lib/castaway/cli/build.rb
+- lib/castaway/cli/main.rb
+- lib/castaway/cli/script.rb
+- lib/castaway/cli/version.rb
+- lib/castaway/effect.rb
+- lib/castaway/element/base.rb
+- lib/castaway/element/matte.rb
+- lib/castaway/element/pointer.rb
+- lib/castaway/element/still.rb
+- lib/castaway/element/text.rb
+- lib/castaway/interpolation.rb
+- lib/castaway/interpolation/linear.rb
+- lib/castaway/point.rb
+- lib/castaway/production.rb
+- lib/castaway/production/audio.rb
+- lib/castaway/production/class_methods.rb
+- lib/castaway/production/scenes.rb
+- lib/castaway/range.rb
+- lib/castaway/relative_to.rb
+- lib/castaway/scene.rb
+- lib/castaway/size.rb
+- lib/castaway/timeline.rb
+- lib/castaway/times.rb
+- lib/castaway/version.rb
+homepage: https://github.com/jamis/castaway
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: System for building screencasts and video presentations
+test_files: []