starter 0.1.1 → 0.1.2

data/Rakefile

@@ -1,4 +1,5 @@
 $:.unshift("lib")
 require "starter/tasks/gems"
+require "starter/tasks/github"
 require "starter/tasks/git"
 

data/lib/starter/extensions/module.rb

@@ -0,0 +1,47 @@
+# "local" methods are those defined directly on a class or module, 
+# as opposed to those inherited or mixed in
+module Starter
+  module Extensions
+
+    module Module
+      
+      def self.basename(mod)
+        mod.name.split('::').last
+      end
+
+      def self.local_methods(mod)
+        mod.public_methods.select do |m|
+          owner = mod.method(m).owner
+          owner == mod.singleton_class || owner == mod
+        end
+      end
+      
+      def self.local_instance_methods(mod)
+        mod.public_instance_methods.select do |m|
+          owner = mod.instance_method(m).owner
+          owner == mod
+        end
+      end
+
+      # For every locally-defined class method, create an instance method
+      # of the same name which operates on the instance.  This allows you
+      # to create Modules which can be used as mixins, but the methods are
+      # also available on the module itself, in case a user does not want
+      # to include the module.
+      def self.create_instance_methods(mod)
+        self.local_methods(mod).each do |method_name|
+          mod.module_eval <<-METHOD, __FILE__, __LINE__
+            def #{method_name}(*args)
+              #{mod}.#{method_name}(self, *args)
+            end
+          METHOD
+        end
+      end
+
+      self.create_instance_methods(self)
+      
+    end
+
+  end
+end
+

data/lib/starter/extensions/string.rb

@@ -0,0 +1,62 @@
+require "starter/extensions/module"
+module Starter
+  module Extensions
+
+    module String
+
+      def self.camel_case(string)  
+        string.split('_').map do |word|
+          "#{word.slice(/^\w/).upcase}#{word.slice(/^\w(\w+)/, 1)}"
+        end.join
+      end
+
+      def self.snake_case(string)
+        string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+      end
+
+      def self.title_case(string)
+        # FIXME: I think that the block form of gsub is not thread safe.
+        string.gsub( /\b\w/ ) { |x| x.upcase }
+      end
+
+      def self.hex(string)
+        string.unpack("H*")[0]
+      end
+
+      def self.unhex(string)
+        [string].pack("H*")
+      end
+
+      def self.xor(str1, str2)
+        a1 = str1.unpack('C*')
+        a2 = str2.unpack('C*') * (str1.length / str2.length + 1)
+        xor = ""
+        0.upto(a1.length - 1) do |i|
+          x = a1[i] ^ a2[i].to_i
+          xor << x.chr()
+        end
+        xor
+      end
+
+      Starter::Extensions::Module.create_instance_methods(self)
+
+      module Compression
+        def self.included(mod)
+          require "zlib"
+        end
+
+        def self.gzip(string)
+          sio = StringIO.new
+          gz = Zlib::GzipWriter.new(sio)
+          gz.write(string)
+          gz.close
+          sio.string
+        end 
+
+        Starter::Extensions::Module.create_instance_methods(self)
+      end
+
+    end
+
+  end
+end

data/lib/starter/http.rb

@@ -0,0 +1,12 @@
+module Starter
+
+  module HTTP
+
+    def self.basic_auth(user, pass)
+      # TODO: I wrote a clearer version of this somewhere.  Find and replace.
+			"Basic #{["#{user}:#{pass}"].pack('m').delete("\r\n")}"
+    end
+
+  end
+
+end

data/lib/starter/misc.rb

@@ -0,0 +1,22 @@
+
+module Starter
+  module Misc
+
+    def marshalize(filename, &block)
+      if File.exist?(filename)
+        File.open(filename) { |f| Marshal.load(f) }
+      elsif File.exist?(filename + ".gz")
+        system "gunzip #{filename}.gz"
+        File.open(filename) { |f| Marshal.load(f) }
+      else
+        val = yield
+        File.open(filename, "w") do |f|
+          Marshal.dump(val, f)
+        end
+        val
+      end
+    end
+
+
+  end
+end

data/lib/starter/mixins/statistics.rb

@@ -0,0 +1,72 @@
+require "starter/extensions/module"
+module Starter
+  module Mixins
+  
+    module Stats
+      
+      def self.summary(items)
+        sorted = items.sort
+        [
+          [:mean, sorted.mean],
+          [:stddev, sorted.standard_deviation],
+          [:min, sorted.first],
+          [:q1, sorted._quartile(1)],
+          [:median, sorted._median],
+          [:q3, sorted._quartile(3)],
+          [:max, sorted.last],
+          [:sample_size, sorted.size]
+        ]
+      end
+
+      def self.sum(items)
+        s = 0; items.each { |element| s += element }; s
+      end
+      
+      def self.mean(items)
+        items.sum.to_f / items.size
+      end
+      
+      def self.variance(items)
+        denom = items.size - 1
+        m = items.mean
+        s = 0
+        items.each { |element| s += (element - m)**2; }
+        s / denom
+      end
+      
+      def self.standard_deviation(items)
+        Math.sqrt( items.variance )
+      end
+      
+      def self.median(items)
+        self._median(items.sort)
+      end
+
+      def self.quartile(items, n)
+        raise ArgumentError unless n > 0 && n < 4
+        self._quartile(items.sort, n)
+      end
+
+      private
+
+      def self._quartile(sorted, n)
+        s = sorted.size
+        sorted[n * s/4]
+      end
+
+      def self._median(sorted)
+        s = sorted.size
+        i = s % 2
+        case i
+         when 0 then sorted[s/2 - 1, 2].mean
+         when 1 then sorted[s/2].to_f
+        end if sorted.size > 0
+      end
+
+      Starter::Extensions::Module.create_instance_methods(self)
+
+    end
+    
+  end
+end
+

data/lib/starter/password.rb

@@ -0,0 +1,28 @@
+require "starter/prompt"
+module Starter
+
+  class Password < String
+    extend Prompt
+
+    def self.request(service)
+      begin
+        system "stty -echo"
+        value = prompt "Password for #{service}:"
+      ensure
+        system "stty echo"
+        puts
+      end
+      self.new(value)
+    end
+
+    def initialize(*args)
+      super
+    end
+
+    def inspect
+      "#<Starter::Password>"
+    end
+
+  end
+
+end

data/lib/starter/prompt.rb

@@ -0,0 +1,24 @@
+module Starter
+
+  module Prompt
+    extend self
+
+    def prompt(string)
+      print "#{string} "
+      value = STDIN.gets.chomp
+      if value.size > 1
+        return value
+      else
+        puts "No, I really need a value. Try again."
+        prompt(string)
+      end
+    end
+
+    def confirm(string)
+      print "#{string} [y/N] "
+      true if STDIN.gets.chomp =~ /^y/i
+    end
+
+  end
+end
+

data/lib/starter/random.rb

@@ -0,0 +1,243 @@
+require "openssl"
+module Starter
+  module Random
+
+    def self.nonce(length)
+      OpenSSL::Random.random_bytes(length).unpack("H*").join
+    end
+
+    # Taken from http://redshift.sourceforge.net/sci/
+    # sci-0.2/lib/sci/random.rb
+    # Contact Joel VanderWerf, vjoel@users.sourceforge.net
+    # No license specified in original. Copyright assumed to be Joel VanderWerf.
+
+    # Base class for sequences that sample different kinds of distributions.
+    # The actual PRNG must be plugged in at initialization, or else ruby's
+    # global PRNG is used.
+    class Sequence
+      include Math
+      
+      class RubyGlobalGenerator
+        def initialize(seed = nil)
+          srand(seed) if seed
+        end
+        def next
+          rand
+        end
+      end
+    
+      attr_reader :generator
+      
+      # Options are :seed and :generator.
+      #
+      # The :generator must either have a method #next that returns
+      # a float between 0 and 1, or a method #new that returns an instance
+      # that has such a #next method.
+      #
+      # If generator is not given, uses ruby's Kernel#rand (beware global state)
+      # and the :seed option.
+      #
+      def initialize opt = {}
+        gen = opt[:generator] || RubyGlobalGenerator
+        if gen.respond_to?(:new)
+          @generator = gen.new(opt[:seed])
+        else
+          @generator = gen
+        end
+      end
+      
+      def self.serial_count
+        @count ||= 0
+        @count += 1
+      end
+      
+      # A utility method for getting a random seed.
+      def self.random_seed
+        Sequence.random_pool_seed ||
+          ((Time.now.to_f * 1_000_000_000).to_i % 1_000_000_000) +
+          Sequence.serial_count + Process.pid
+      end
+      
+      @@have_dev_random = true # assume so until evidence to contrary
+      
+      def self.random_pool_seed
+        ## could also get random data from net
+        if @@have_dev_random
+          @random_pool ||= ""
+          if @random_pool.length < 4
+            File.open('/dev/random') do |dr|
+              if select([dr],nil,nil,0)
+                @random_pool << dr.sysread(100)
+              end
+            end
+          end
+          if @random_pool.length >= 4
+            @random_pool.slice!(-4..-1).unpack('L')[0]
+          end
+        end
+      rescue SystemCallError
+        @@have_dev_random = false
+      end
+      
+      def next
+        @generator.next
+      end
+    end
+    
+    class ConstantSequence < Sequence
+      attr_reader :mean
+      
+      def initialize opt = {}
+        @mean = Float(opt[:mean] || 0)
+      end
+      
+      def next
+        @mean
+      end
+    end
+    
+    class UniformSequence < Sequence
+      attr_reader :min, :max
+      
+      def initialize opt = {}
+        super
+        @min = Float(opt[:min] || 0)
+        @max = Float(opt[:max] || 1)
+        @delta = @max - @min
+      end
+      
+      def next
+        @min + @delta*super
+      end
+    end
+    
+    class ExponentialSequence < Sequence
+      attr_reader :mean
+      
+      def initialize opt = {}
+        super
+        @mean = Float(opt[:mean] || 1)
+      end
+    
+      def next
+        while (x=super) == 0.0; end
+        return -log(x) * @mean
+      end
+    end  
+
+    class GaussianSequence < Sequence
+      attr_reader :mean, :stdev, :min, :max
+      
+      def initialize opt = {}
+        super
+        @mean = Float(opt[:mean] || 0)
+        @stdev = Float(opt[:stdev] || 1)
+        @min = opt[:min]; @min = Float(@min) if @min
+        @max = opt[:max]; @max = Float(@max) if @max
+        @nextnext = nil
+      end
+    
+      def next
+        if @nextnext
+          result = @mean + @nextnext*@stdev
+          @nextnext = nil
+        
+        else
+          begin
+            v1 = 2 * super - 1
+            v2 = 2 * super - 1
+            rsq = v1*v1 + v2*v2
+          end while rsq >= 1 || rsq == 0
+
+          fac = sqrt(-2*log(rsq) / rsq)
+          @nextnext = v1*fac
+          result = @mean + v2*fac*@stdev
+        end
+        
+        if @min and result < @min
+          result = @min
+        elsif @max and result > @max
+          result = @max
+        end
+        
+        return result
+      end
+    end
+
+    # Based on newran02:
+    #
+    #   Real VariLogNormal::Next(Real mean, Real sd)
+    #   {
+    #      // should have special version of log for small sd/mean
+    #      Real n_var = log(1 + square(sd / mean));
+    #      return mean * exp(N.Next() * sqrt(n_var) - 0.5 * n_var);
+    #   }
+    #
+    class LogNormalSequence < Sequence
+      attr_reader :mean, :stdev
+      
+      def initialize opt = {}
+        @gaussian_seq = GaussianSequence.new(
+          :mean   => 0,
+          :stdev  => 1,
+          :seed   => opt[:seed],
+          :generator => opt[:generator]
+        )
+        
+        super :generator => @gaussian_seq
+
+        @mean = Float(opt[:mean] || 1)
+        @stdev = Float(opt[:stdev] || 1)
+        
+        n_var = log(1 + (stdev / mean)**2)
+        @sqrt_n_var = sqrt(n_var)
+        @half_n_var = 0.5 * n_var
+      end
+      
+      def next
+        mean * exp(super() * @sqrt_n_var - @half_n_var)
+      end
+    end
+
+    class DiscreteSequence < Sequence
+      attr_reader :distrib
+      
+      def initialize opt = {}
+        super
+        @distrib = opt[:distrib] || { 0 => 1.0 }
+        
+        sum = @distrib.inject(0) {|sum, (pt, prob)| sum + prob}
+        sum = sum.to_f # so division is ok
+        
+        @distrib.keys.each do |point|
+          @distrib[point] /= sum
+        end
+      end
+      
+      def next
+        loop do
+          r = super
+          @distrib.each do |point, probability|
+            if r < probability
+              return point
+            end
+            r -= probability
+          end
+          # repeat if failed to get a result (due to floating point imprecision)
+        end
+        ## this would be faster using an rbtree
+      end
+    end
+
+    Constant                = ConstantSequence
+    Uniform                 = UniformSequence
+    Exponential             = ExponentialSequence
+    Gaussian                = GaussianSequence
+    Normal = NormalSequence = GaussianSequence
+    LogNormal               = LogNormalSequence
+    Discrete                = DiscreteSequence
+
+  end
+
+
+end

data/lib/starter/tasks/bootstrap.rb

@@ -1,4 +1,4 @@
-require "starter/tasks/helpers"
+require "starter/tasks/starter"
 
 $STARTER[:directory] = File.basename(Dir.pwd)
 $STARTER[:gemspec_file] = "#{$STARTER[:directory]}.gemspec"

data/lib/starter/tasks/gems.rb

@@ -1,4 +1,4 @@
-require "starter/tasks/helpers"
+require "starter/tasks/starter"
 
 gemspec_path = FileList["*.gemspec"].first || "#{$STARTER[:directory]}.gemspec"
 project_name = gemspec_path.chomp(".gemspec")
@@ -13,14 +13,14 @@ directory "lib"
 file "lib/#{project_name}.rb" do |target|
   File.open(target.name, "w") do |file|
     file.puts <<-TXT
-module #{Starter::String.camel_case(project_name)}
+module #{Starter::Extensions::String.camel_case(project_name)}
 
 end
     TXT
   end
 end
 
-file gemspec_path => %w[ determine_author ] do |target|
+file gemspec_path do |target|
   File.open(target.name, "w") do |file|
     file.puts gemspec_template(
       :author => $STARTER[:author],
@@ -51,6 +51,15 @@ task "gem:dependencies" => "gemspec" do
   require "pp"
   pp gemspec.dependencies.first
   # install dependencies from gemspec
+
+	#require 'rubygems/dependency_installer'
+	#gems = Gem::SourceIndex.from_installed_gems
+	#installer = Gem::DependencyInstaller.new
+	#spec.dependencies.each do |dep|
+		#if gems.find_name(dep.name, dep.requirement).empty?
+			#installer.install(dep.name, dep.requirement)
+		#end
+	#end
 end
 
 task "version" => "read_gemspec" do

data/lib/starter/tasks/git.rb

@@ -1,4 +1,4 @@
-require "starter/tasks/helpers"
+require "starter/tasks/starter"
 
 task "release" => %w[ git:tag ]
 

data/lib/starter/tasks/github.rb

@@ -0,0 +1,93 @@
+require "starter/tasks/starter"
+
+desc "Create an issue on GitHub"
+task "github:issue" => "github_repo" do
+
+  repo = $STARTER[:github_repo]
+  options = {}
+  $stdout.print "Title: "; $stdout.flush
+  options[:title] = $stdin.readline.strip
+  $stdout.print "Description: "; $stdout.flush
+  options[:description] = $stdin.readline.strip
+  labels = repo.labels.map { |label| label["name"] }.join(" ")
+  $stdout.print "Labels (separate with spaces: [#{labels}]): "; $stdout.flush
+  options[:labels] = $stdin.readline.strip.split(" ")
+  $stdout.puts "Milestone:"
+  repo.milestones.each do |milestone|
+    $stdout.puts "#{milestone['number']} - #{milestone['title']}"
+  end
+  milestone = $stdin.readline.strip
+  options[:milestone] = milestone unless milestone.empty?
+
+  print "Issue details: "
+  if Starter::Prompt.confirm("Create this issue?")
+    result = repo.issues.create(options)
+    if result["errors"]
+      result["errors"].each do |error|
+        $stderr.puts "#{error['resource']}: #{error['message']}"
+      end
+    else
+      $stdout.puts "Issue ##{result['number']} created."
+    end
+  end
+end
+
+
+task "github_repo" => %w[ github_settings github_password ] do
+  require 'ghee'
+
+  settings = $STARTER[:settings][:github]
+  user, password, repo = settings.values_at(:user, :password, :repo)
+  ghee = Ghee.basic_auth(user,password)
+
+  repo = ghee.repos(repo[:owner], repo[:name])
+  if repo["message"]
+    puts repo["message"]
+    exit
+  else
+    $STARTER[:github_repo] = repo
+  end
+
+end
+
+
+task "github_password" => "github_settings" do
+  require "starter/password"
+  if $STARTER[:settings][:github][:password] == nil
+    password = Starter::Password.request("GitHub")
+    $STARTER[:settings][:github][:password] = password
+  end
+end
+
+
+task "read_settings" do
+  require "yaml"
+  begin
+    $STARTER[:settings] = YAML.load_file("settings.yml")
+  rescue Errno::ENOENT
+    $stderr.puts "You do not appear to have a settings.yml file."
+    if Starter::Prompt.confirm("Create a stubbed settings file?")
+      File.open("settings.yml", "w") do |f|
+        settings = {
+          :github => {
+            :user => "YOURUSERNAME",
+            :repo => {:owner => "OWNERNAME", :name => $STARTER[:directory]}
+          }
+        }
+        YAML.dump(settings, f)
+        puts "Created settings.yml. Now go edit it and add it to .gitignore."
+      end
+    end
+    exit
+  end
+end
+
+
+task "github_settings" => "read_settings" do
+  if $STARTER[:settings][:github] == nil
+    $stderr.puts "Looks like your settings.yml file isn't set up with a github stanza."
+    exit
+  end
+end
+
+

data/lib/starter/tasks/markdown.rb

@@ -13,7 +13,7 @@ end
 def readme(options)
   project_name = options[:project_name]
   text = <<-TXT
-# #{Starter::String.camel_case(project_name)}
+# #{Starter::Extensions::String.camel_case(project_name)}
 
   TXT
 end

data/lib/starter/tasks/npm.rb

@@ -3,13 +3,40 @@
 task "bootstrap" => %w[ package.json ]
 
 file "package.json" => %w[ determine_author ] do |target|
-  string = package_template(options)
   File.open(target.name, "w") do |file|
+    file.puts package(
+      :project_name => $STARTER[:directory],
+      :author => $STARTER[:author],
+    )
   end
 end
 
-def package_template(options={})
+
+task "npm:release" => %w[ npm:publish ]
+
+task "npm:publish" do
+  sh "npm publish"
+end
+
+
+
+def package(options={})
+  project_name, author = options.values_at(:project_name, :author)
   package = <<-TXT
+{
+  "name": "#{project_name}",
+  "description": "A new project, a nascent bundle of win, whose author hasn't described it yet.",
+  "author": "#{author}",
+  "version": "0.1.0",
+  "main": "./lib/#{project_name}.js",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+  },
+  "devDependencies": {
+  }
+}
   TXT
 end
 

data/lib/starter/tasks/{helpers.rb → starter.rb}

@@ -1,13 +1,16 @@
 require "pp"
-require "starter/string"
+require "starter/prompt"
+require "starter/extensions/string"
 require "git"
 
 $STARTER ||= {}
 
 $STARTER[:directory] = File.basename(Dir.pwd)
 
+# Interface task declarations
+
 desc "Bootstrap your project"
-task "bootstrap"
+task "bootstrap" => "determine_author"
 
 desc "Build everything that needs building"
 task "build"
@@ -15,11 +18,12 @@ task "build"
 desc "Release the dogs that shoot bees from their mouths"
 task "release" => %w[ build ]
 
+
 task "determine_author" => %w[ read_git_config ] do
   if author = $STARTER[:git].config["user.name"]
     $STARTER[:author] = author
   else
-    $STARTER[:author] = prompt("Project author?")
+    $STARTER[:author] = Starter::Prompt.prompt("Project author?")
   end
 end
 
@@ -28,10 +32,9 @@ task "read_git_config" do
   $STARTER[:git] = g
 end
 
+
 def confirm_command(command)
-  print "Issue command '#{command}' [y/N] "
-  case STDIN.gets.chomp
-  when /^y/i
+  if Starter::Prompt.confirm("Issue command '#{command}'?")
     sh command
   else
     puts "Cancelled."
@@ -39,14 +42,4 @@ def confirm_command(command)
   end
 end
 
-def prompt(string)
-  print "#{string} "
-  value = STDIN.gets.chomp
-  if value.size > 1
-    return value
-  else
-    puts "No, I really need a value. Try again."
-    prompt(string)
-  end
-end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: starter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-08 00:00:00.000000000 Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -20,13 +20,21 @@ files:
 - LICENSE
 - Rakefile
 - README.md
-- lib/starter/string.rb
+- lib/starter/extensions/module.rb
+- lib/starter/extensions/string.rb
+- lib/starter/http.rb
+- lib/starter/misc.rb
+- lib/starter/mixins/statistics.rb
+- lib/starter/password.rb
+- lib/starter/prompt.rb
+- lib/starter/random.rb
 - lib/starter/tasks/bootstrap.rb
 - lib/starter/tasks/gems.rb
 - lib/starter/tasks/git.rb
-- lib/starter/tasks/helpers.rb
+- lib/starter/tasks/github.rb
 - lib/starter/tasks/markdown.rb
 - lib/starter/tasks/npm.rb
+- lib/starter/tasks/starter.rb
 homepage: https://github.com/automatthew/starter
 licenses: []
 post_install_message: 

data/lib/starter/string.rb

@@ -1,16 +0,0 @@
-
-module Starter
-  module String
-    extend self
-    def camel_case( string )  
-      string.split('_').map do |word|
-        "#{word.slice(/^\w/).upcase}#{word.slice(/^\w(\w+)/, 1)}"
-      end.join
-    end
-
-    def snake_case( string )
-      string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-    end
-  end
-end
-