ghost_story 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 020b2e0af5ba93bd0e06bd61a169e70b81f733a7
+  data.tar.gz: eab86597a9bf8e43da885b7ae63417c43fca8a33
+SHA512:
+  metadata.gz: cb90b38182d47f2292fee3ff53b5c31f8f765c554c87de1bfc71e995fc0e1629b5311c98e33c0c2caf37492d1b4f222d48298de29d77001a98a61167a6b10fd1
+  data.tar.gz: 9c38d6f324b3318bd98c1a9bdbdcc1e05d6f805ea03fec2bd1d6d97620e82afd087441df01cbb88bd82067a4d4b34b1281b4d0331833d054e161a0136d3aada6

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ghost_story.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Franklin Webber
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# GhostStory
+
+Ghost Story allows you to write a story in markdown. The story can then be
+read back to you. A ghost story is both text and automated scripts that will
+type out code.
+
+The initial use case is for composing repeatable screencasts. When you set out
+to write a screencast you often times compose a script and the code that
+accompanies it. There are some inherent problems with this manual method of
+telling a story:
+
+- Typing the code is cumbersome and error prone
+- Removing errors and mistyping during the editing process is a waste of time
+- Editing or updating your screencast later requires you re-create an entire section manually.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ghost_story'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ghost_story
+
+## Usage
+
+First write the script that you want to execute in markdown.
+
+    # Ruby Classes
+
+    If you are already familar with classes in other languages, you will have
+    no time understanding how they are created in Ruby.
+
+    ~~~~
+    class Square
+
+      def initialize(height)
+        @height = height
+      end
+
+      attr_reader :height
+
+      def area
+        height * height
+      end
+    end
+    ~~~~
+
+Then with the completed script you run the `ghost_story` binary which will
+read the story and then create an interactive version which will show you the
+written parts and then type the code between the code fences.
+
+> Some limitation in Kramdown, which is used to generate an object representation
+> of the document, works consistently with the `~~~` instead of the three backticks.
+
+```
+$ ghost_story tell ruby_classes.md APPLICATION
+```
+
+The application you specify is important. That is the name of the
+Appliation that the key events will be sent. At the moment, this is
+fairly simplistic and will really only work with non-Terminal editors.
+
+> Also, note that if your editor helps you with auto indention when you are
+> writing code, this will need to be turned off. I found that
+> with Sublime Text I needed to set `"auto_indent": false` for example.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/ghost_story/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/ghost_story

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+path = __FILE__
+while File.symlink?(path)
+  path = File.expand_path(File.readlink(__FILE__), File.dirname(__FILE__))
+end
+$:.unshift(File.join(File.dirname(File.expand_path(path)), '..', 'lib'))
+
+require "ghost_story"
+require "commands/thor"
+
+GhostStory::Thor.start

data/ghost_story.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ghost_story/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ghost_story"
+  spec.version       = GhostStory::VERSION
+  spec.authors       = ["Franklin Webber"]
+  spec.email         = ["franklin.webber@gmail.com"]
+  spec.summary       = %q{Markdown driving automation used for screencasts or walkthroughs of code where you don't want to type.}
+
+  spec.description   = %q{Ghost Story allows you to write a story in markdown. The story can then be
+read back to you. A ghost story is both text and automated scripts that will
+type out code.}
+
+  spec.homepage      = "https://github.com/burtlo/ghost_story"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dutchman", ">= 0.0.1"
+  spec.add_dependency "formatador", "~> 0.2"
+  spec.add_dependency "kramdown", "~> 1.1"
+  spec.add_dependency "thor", "~> 0.18"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/lib/commands/thor.rb

@@ -0,0 +1,35 @@
+require 'thor'
+# require 'thor/group'
+
+module GhostStory
+
+  class Thor < Thor
+
+    no_tasks do
+
+      def banner
+        """
+********************************************************************************
+Ghost Story BOOO!
+-------------------------------------------------------------------------------"""
+      end
+
+    end
+
+    desc "tell STORYFILE APPLICATION",
+      "Tell the story contained in the file"
+    def tell(story_file,application=nil)
+      # TODO: find out of the file is real!
+      # TODO: Seems Thor has an options hash, so this is probabyly a bad name
+      options = { application: application }
+      GhostStory.read_file(story_file,options)
+    end
+
+    desc "help", "This commoand"
+    def help
+      say banner
+      print_table self.class.printable_tasks, indent: 4
+    end
+
+  end
+end

data/lib/ghost_story.rb

@@ -0,0 +1,24 @@
+require "kramdown"
+require "formatador"
+require "pry"
+
+require "dutchman"
+
+require "ghost_story/version"
+require "ghost_story/story_builder"
+require "ghost_story/story"
+
+
+module GhostStory
+
+  def self.read_file(story_file,options = {})
+    read File.read(story_file), options
+  end
+
+  def self.read(story,options = {})
+    story_builder = StoryBuilder.new(options)
+    story = story_builder.build(story)
+    story.read!
+  end
+
+end

data/lib/ghost_story/story.rb

@@ -0,0 +1,20 @@
+module GhostStory
+
+  class Story
+    def initialize(whole_story)
+      @whole_story = whole_story
+    end
+
+    attr_reader :whole_story
+
+    def read!
+      clear_screen
+      whole_story.each { |piece| piece.call }
+    end
+
+    def clear_screen
+      puts "\e[H\e[2J"
+    end
+  end
+
+end

data/lib/ghost_story/story_builder.rb

@@ -0,0 +1,123 @@
+module GhostStory
+
+  class StoryBuilder
+
+    def initialize(options)
+      @options = options || {}
+    end
+
+    attr_reader :options
+
+    #
+    # @returns [Story] a story object is something that can be executed to tell
+    #   the story created by the builder.
+    #
+    def build(story)
+      kram = Kramdown::Document.new(story)
+
+      whole_story = build_story(kram.root)
+
+      Story.new(whole_story)
+    end
+
+    private
+
+    #
+    # @returns [Array<lambda>] an array of executable objects which
+    #   will either display text to the screen or drive the editor to
+    #   type in the desired code.
+    #
+    def build_story(node_with_children)
+      node_with_children.children.map { |node| build_chapter(node) }
+    end
+
+    #
+    # Building a chapter creates and returns a delayed block of code for the
+    # particular node. It is packaged like this so that each chapter can be
+    # placed into an array of all the chapters that need to be executed. Ensuring
+    # that they execute in the correct order.
+    #
+    # @returns [lambda] the code that needs to be written or the text that needs
+    #   to be displayed to the reader.
+    def build_chapter(node)
+      if node_contains_code?(node)
+        build_code_chapter(node)
+      else
+        lambda { Formatador.display build_standard_chapter(node) }
+      end
+    end
+
+    #
+    # Currently a node that identifies as a codeblock is any node using the
+    # three "~~~" syntax. Previously, I was using the more conventional three
+    # backticks "```" but those are converted to codespans. This is a limitation
+    # of using Kramdown.
+    #
+    def node_contains_code?(node)
+      node.type == :codeblock
+    end
+
+    #
+    # Nodes identified as a code chapter will first ask for input from the person
+    # running the story and then it will execute the story.
+    #
+    def build_code_chapter(node)
+      code = node.value
+      lambda { ask_to_continue ; Dutchman.write(to: application, text: code, speed: :fast, humanize: true) }
+    end
+
+    #
+    # The application to which to write the code.
+    #
+    def application
+      options[:application] || default_application
+    end
+
+    #
+    # This default value is not kosher!
+    #
+    def default_application
+      "Sublime Text"
+    end
+
+    #
+    # Prompts the person running the story to press a key to continue with
+    # with the story. This allows them to read the human parts and continue
+    # with the typed parts as necessary.
+    #
+    def ask_to_continue
+      Formatador.display_line "\n\n*** [bold]Press ENTER to type CODE[/] ***"
+      STDIN.gets
+    end
+
+    #
+    # A non-code portion of the story simply needs to be collected up and
+    # a string needs to be created from it. This method is called recursively
+    # to child elements to create the entire string to be displayed. There
+    # are some simple rules for headers to make them a particular color.
+    #
+    def build_standard_chapter(node)
+
+      story_so_far = ""
+
+      story_so_far += "\n#{header_display_color}" if node.type == :header
+      story_so_far += node.value if node.type == :text
+
+      if not node.children.empty?
+        node.children.each do |child|
+          story_so_far += build_standard_chapter(child).to_s
+        end
+      end
+
+      story_so_far += "[/]\n" if node.type == :header
+
+      story_so_far
+    end
+
+    def header_display_color
+      "[green]"
+    end
+
+  end
+
+end

data/lib/ghost_story/version.rb

@@ -0,0 +1,3 @@
+module GhostStory
+  VERSION = "0.0.1"
+end

data/lib/untitled

@@ -0,0 +1,4 @@
+
+class A ; end
+
+class A ; end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: ghost_story
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Franklin Webber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dutchman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: formatador
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Ghost Story allows you to write a story in markdown. The story can then be
+  read back to you. A ghost story is both text and automated scripts that will
+  type out code.
+email:
+- franklin.webber@gmail.com
+executables:
+- ghost_story
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ghost_story
+- ghost_story.gemspec
+- lib/commands/thor.rb
+- lib/ghost_story.rb
+- lib/ghost_story/story.rb
+- lib/ghost_story/story_builder.rb
+- lib/ghost_story/version.rb
+- lib/untitled
+homepage: https://github.com/burtlo/ghost_story
+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.1.9
+signing_key: 
+specification_version: 4
+summary: Markdown driving automation used for screencasts or walkthroughs of code
+  where you don't want to type.
+test_files: []
+has_rdoc: