cmd_stan_rb 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 71cc2e69241ee94c83e321260b0f612c75c1dd9f4b3c13b1f1c71b50d2ebbeff
+  data.tar.gz: f5e04d315c5dfb5d0a7a3a85d950cb0704be044b0fe2d7dd630a6656cd0b2c53
+SHA512:
+  metadata.gz: 6e769bb30bb9e0c14fbe344a3576006cb7874ab592cf87989204cbb2f3f3de56499bc6e8bb5bf7e58d3dc44a2896c0d8572151eaf45f6eb382c83431044cb4e2
+  data.tar.gz: dd013cd4b43cdff86449f578ed0ba9027c0a926e73e992475a241aff7e5ccde10cf157e6b612d4a73ee410428748adcd3c7ad28484c0eb84c989de53a07e1fa3

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/models/
+/vendor/
+*.csv
+/output/
+# rspec failure tracking
+.rspec_status
+/.ipynb_checkpoints/
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 2.1.3

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+### Head (Not released yet)
+
+### v0.2.0
+
+* Renaming to CmdStanRb (See #5)
+
+### v0.1.1
+
+* Make model storage location configurable (#2)
+* Make loading previously compiled models work
+
+### v0.1.0
+
+* Initial Version
+

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ruby_stan.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    cmd_stan_rb (0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cmd_stan_rb!
+  rake (~> 12.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Robin Neumann
+
+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,141 @@
+# CmdStanRb
+[![Build Status](https://travis-ci.org/neumanrq/cmd_stan_rb.svg?branch=master)](https://travis-ci.org/neumanrq/cmd_stan_rb)
+
+Ruby interface to Stan, a library a for performing high performance statistical computations, i.e.
+full Bayesian Inference.
+
+<a href="https://mc-stan.org">
+  <img src="https://raw.githubusercontent.com/stan-dev/logos/master/logo.png" width=200 alt="Stan Logo"/>
+</a>
+
+
+## Installation
+
+    gem install cmd_stan_rb
+
+## Installation for IRuby notebooks
+
+    gem install cmd_stan_rb
+
+… and then re-register your Ruby kernel by
+
+    iruby register --force
+
+## Before you can start…
+
+This project makes use of [CmdStan](https://github.com/stan-dev/cmdstan) to compile models
+with the Stan compiler and incorporating additional tooling from the Stan ecosystem. There
+are battle-tested similar projects for other Programming languages are i.e.
+
+  * [CmdStanPy](https://github.com/stan-dev/cmdstanpy)
+  * [CmdStanR](https://github.com/stan-dev/cmdstanr)
+  * [stannis](https://github.com/sakrejda/stannis])
+
+Because of its dependency to `CmdStan`, you need to get `CmdStan` on board to
+make `CmdStanRb` work. In the future I'd like to happen this automatically, but
+for now you need to do this manually.
+
+The easiest way is cloning the repository to a location of your choice:
+
+    git clone https://github.com/stan-dev/cmdstan
+
+Then, remember the path to that directory, as we need CmdStanRb to point
+to that directory by setting a config variable
+
+## Usage
+
+
+```Ruby
+# Tell CmdStanRb where your CmdStan repository is located.
+# If you skip this step, the default value is "vendor/cmdstan"
+# as I have cloned it there for my experimentation.
+CmdStanRb.configuration.cmdstan_dir = "~/path/to/cmdstan"
+
+# Optional: Tell CmdStanRb where to store the models
+CmdStanRb.configuration.model_dir = "/Users/robin/cmd_stan_rb-models"
+
+# Prepare Stan compiler and assistent tooling
+CmdStanRb.build_binaries
+
+# Now we're ready to fit some models 👨‍🔬
+# First, define your model. The first argument is a name,
+# which is used to identify your model for re-use later.
+model =
+  Stan::Model.new("bernoulli-test") do
+    # Stan code goes here as a string
+    %q{
+      data {
+        int<lower=0> N;
+        int<lower=0,upper=1> y[N];
+      }
+
+      parameters {
+        real<lower=0,upper=1> theta;
+      }
+
+      model {
+        theta ~ beta(1,1);  // uniform prior on interval 0,1
+        y ~ bernoulli(theta);
+      }
+    }
+  end
+
+# Translate model
+model.compile
+
+# Specify data you've observed
+model.data = {
+  "N" => 4,
+  "y" => [0,1,0,0]
+}
+
+# Run simulation to obtain samples from posterior distribution
+model.fit
+
+# Print result
+puts model.show
+```
+
+The latter command shows the simulation result:
+
+
+    Inference for Stan model: b439_model
+    1 chains: each with iter=(1000); warmup=(0); thin=(1); 1000 iterations saved.
+
+    Warmup took (0.0062) seconds, 0.0062 seconds total
+    Sampling took (0.013) seconds, 0.013 seconds total
+
+                    Mean     MCSE  StdDev     5%   50%   95%    N_Eff  N_Eff/s    R_hat
+    lp__            -4.4  3.5e-02    0.77   -5.9  -4.1  -3.8  4.9e+02  3.7e+04  1.0e+00
+    accept_stat__   0.90  4.4e-03    0.15   0.53  0.97   1.0  1.2e+03  9.2e+04  1.0e+00
+    stepsize__       1.1      nan    0.00    1.1   1.1   1.1      nan      nan      nan
+    treedepth__      1.4  1.5e-02    0.48    1.0   1.0   2.0  1.0e+03  7.6e+04  1.0e+00
+    n_leapfrog__     2.3  3.2e-02    0.97    1.0   3.0   3.0  9.2e+02  6.8e+04  1.0e+00
+    divergent__     0.00      nan    0.00   0.00  0.00  0.00      nan      nan      nan
+    energy__         4.9  5.2e-02     1.1    3.9   4.6   6.8  4.3e+02  3.2e+04  1.0e+00
+    theta           0.34  9.3e-03    0.18  0.071  0.32  0.64  3.7e+02  2.7e+04  1.0e+00
+
+    Samples were drawn using hmc with nuts.
+    For each parameter, N_Eff is a crude measure of effective sample size,
+    and R_hat is the potential scale reduction factor on split chains (at
+    convergence, R_hat=1).
+
+### Loading previously compiled models
+
+CmdStanRb stores models in a diretory you can define by
+
+```Ruby
+CmdStanRb.configuration.model_dir = "/Users/robin/cmd_stan_rb-models"
+```
+
+If you skip this, CmdStanRb will create a folder in your home directory named `cmd_stan_rb-models` and store
+the model files and the compiled model binaries there.
+
+Having compiled a model with name `my-model-01`, you can load it again by
+
+```Ruby
+model = Stan::Model.load("my-model-01")
+```
+
+Note that once loaded, the model's data has been wiped out, so `model.data` is blank and
+needs to get set again to fit again.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cmd_stan_rb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cmd_stan_rb.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/cmd_stan_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cmd_stan_rb"
+  spec.version       = CmdStanRb::VERSION
+  spec.authors       = ["Robin Neumann\n"]
+  spec.email         = ["robin.neumann@posteo.de"]
+
+  spec.summary       = %q{Ruby interface to CmdStan, the command line interface to Stan, a high performance statistical computing platform}
+  spec.description   = %q{Stan is a state-of-the-art platform for statistical modeling and high-performance statistical computation. Thousands of users rely on Stan for statistical modeling, data analysis, and prediction in the social, biological, and physical sciences, engineering, and business. CmdStanRb offers bindings in Ruby to employ Stan, targeting easing up the integration of Stan and Bayesian Inference into Ruby-powered environments.}
+  spec.homepage      = "https://github.com/neumanrq/cmd_stan_rb"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/neumanrq/cmd_stan_rb"
+  spec.metadata["changelog_uri"] = "https://github.com/neumanrq/cmd_stan_rb"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/demo.ipynb

@@ -0,0 +1,231 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"0.1.0\""
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "require \"cmd_stan_rb\"\n",
+    "CmdStanRb::VERSION"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "          data {\n",
+      "            int<lower=0> N;\n",
+      "            int<lower=0,upper=1> y[N];\n",
+      "          }\n",
+      "\n",
+      "          parameters {\n",
+      "            real<lower=0,upper=1> theta;\n",
+      "          }\n",
+      "\n",
+      "          model {\n",
+      "            theta ~ beta(1,1);  // uniform prior on interval 0,1\n",
+      "            y ~ bernoulli(theta);\n",
+      "          }\n",
+      "        \n"
+     ]
+    }
+   ],
+   "source": [
+    "puts CmdStanRb::Examples.bernoulli"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Given some data and our prior knowledge. What is the value of theta?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "#<CmdStanRb::Model:0x00007f81aaa9f050 @name=\"research-42\", @model_string=\"\\n          data {\\n            int<lower=0> N;\\n            int<lower=0,upper=1> y[N];\\n          }\\n\\n          parameters {\\n            real<lower=0,upper=1> theta;\\n          }\\n\\n          model {\\n            theta ~ beta(1,1);  // uniform prior on interval 0,1\\n            y ~ bernoulli(theta);\\n          }\\n   \", @model_file=#<File:output/research-42/research-42.stan>>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = CmdStanRb::Model.new(\"research-42\") do \n",
+    "  # Write Stan code here\n",
+    "  %Q{\n",
+    "          data {\n",
+    "            int<lower=0> N;\n",
+    "            int<lower=0,upper=1> y[N];\n",
+    "          }\n",
+    "\n",
+    "          parameters {\n",
+    "            real<lower=0,upper=1> theta;\n",
+    "          }\n",
+    "\n",
+    "          model {\n",
+    "            theta ~ beta(1,1);  // uniform prior on interval 0,1\n",
+    "            y ~ bernoulli(theta);\n",
+    "          }\n",
+    "   }   \n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{:state=>:ok, :target=>\"../../output/research-42/research-42\", :working_directory=>\"/Users/robin/private_projects/cmd_stan_rb\"}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.compile"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{\"N\"=>5, \"y\"=>[1, 0, 1, 1, 0]}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.data = { \n",
+    "  \"N\" => 5, # We toss a coin 5 times \n",
+    "  \"y\" => [1, 0, 1, 1, 0] # toss results\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/robin/private_projects/cmd_stan_rb/output/research-42/research-42 sample data file=output/research-42/research-42.json\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{:state=>:ok, :data=>{\"N\"=>5, \"y\"=>[1, 0, 1, 1, 0]}}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Do the simulation magic\n",
+    "model.fit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inference for Stan model: research_42_model\n",
+      "1 chains: each with iter=(1000); warmup=(0); thin=(1); 1000 iterations saved.\n",
+      "\n",
+      "Warmup took (0.0058) seconds, 0.0058 seconds total\n",
+      "Sampling took (0.013) seconds, 0.013 seconds total\n",
+      "\n",
+      "                Mean     MCSE   StdDev    5%   50%   95%    N_Eff  N_Eff/s    R_hat\n",
+      "lp__            -5.4  4.9e-02  8.7e-01  -7.0  -5.1  -4.8  3.2e+02  2.5e+04  1.0e+00\n",
+      "accept_stat__   0.91  4.0e-03  1.3e-01  0.63  0.97   1.0  1.1e+03  8.8e+04  1.0e+00\n",
+      "stepsize__       1.1      nan  4.4e-15   1.1   1.1   1.1      nan      nan      nan\n",
+      "treedepth__      1.4  1.5e-02  4.8e-01   1.0   1.0   2.0  1.0e+03  8.1e+04  1.0e+00\n",
+      "n_leapfrog__     2.3  3.5e-02  9.7e-01   1.0   3.0   3.0  7.7e+02  6.0e+04  1.0e+00\n",
+      "divergent__     0.00      nan  0.0e+00  0.00  0.00  0.00      nan      nan      nan\n",
+      "energy__         5.9  6.2e-02  1.1e+00   4.8   5.5   8.1  3.3e+02  2.6e+04  1.0e+00\n",
+      "theta           0.57  1.1e-02  1.8e-01  0.25  0.58  0.86  2.6e+02  2.1e+04  1.0e+00\n",
+      "\n",
+      "Samples were drawn using hmc with nuts.\n",
+      "For each parameter, N_Eff is a crude measure of effective sample size,\n",
+      "and R_hat is the potential scale reduction factor on split chains (at \n",
+      "convergence, R_hat=1).\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "puts model.show"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Ruby 2.6.5",
+   "language": "ruby",
+   "name": "ruby"
+  },
+  "language_info": {
+   "file_extension": ".rb",
+   "mimetype": "application/x-ruby",
+   "name": "ruby",
+   "version": "2.6.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

data/lib/cmd_stan_rb.rb

@@ -0,0 +1,28 @@
+require "json"
+require "cmd_stan_rb/version"
+require "cmd_stan_rb/configuration"
+require "stan"
+
+module CmdStanRb
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :configuration
+
+    def build_binaries
+      system("make -C #{CmdStanRb.configuration.cmdstan_dir} build")
+    end
+
+    def reset
+      system("make -C #{CmdStanRb.configuration.cmdstan_dir} clean-all")
+    end
+  end
+
+  def self.configuration
+    @configuration ||= CmdStanRb::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/cmd_stan_rb/configuration.rb

@@ -0,0 +1,11 @@
+module CmdStanRb
+  class Configuration
+    attr_accessor :cmdstan_dir
+    attr_accessor :model_dir
+
+    def initialize
+      self.cmdstan_dir = "vendor/cmdstan"
+      self.model_dir = "#{`echo $HOME`.gsub("\n", "")}/cmd_stan_rb-models"
+    end
+  end
+end

data/lib/cmd_stan_rb/version.rb

@@ -0,0 +1,3 @@
+module CmdStanRb
+  VERSION = "0.2.0"
+end

data/lib/stan.rb

@@ -0,0 +1,5 @@
+require "stan/model"
+require "stan/examples"
+
+module Stan
+end

data/lib/stan/examples.rb

@@ -0,0 +1,23 @@
+module Stan
+  module Examples
+    class << self
+      def bernoulli
+        %q{
+          data {
+            int<lower=0> N;
+            int<lower=0,upper=1> y[N];
+          }
+
+          parameters {
+            real<lower=0,upper=1> theta;
+          }
+
+          model {
+            theta ~ beta(1,1);  // uniform prior on interval 0,1
+            y ~ bernoulli(theta);
+          }
+        }
+      end
+    end
+  end
+end

data/lib/stan/model.rb

@@ -0,0 +1,106 @@
+module Stan
+  class Model
+    class NoDataGivenError < StandardError ;; end
+
+    attr_accessor :compiled_model_path, :name, :data
+    attr_reader :model_string, :model_file
+
+    class << self
+      def load(name)
+        new(name)
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+
+      # I'd like to invent a convenient DSL that
+      # is similar to writing "direct" Stan code,
+      # but to do so I need to get a better understanding
+      # of Stan as a language/DSL itself. Until that
+      # I "approximate" my goal by using a block for initialization,
+      # where the block always needs to return the Stan model
+      # as a string. You can load it from a file or write in directly!
+      @model_string = block.call if block_given?
+
+      `mkdir -p #{model_directory}` unless Dir.exists?(model_directory)
+
+      if File.exists?(filename)
+        load_model_file
+      else
+        create_model_file!
+      end
+    end
+
+    # Main interactions
+    #
+    #
+
+    def compile
+      system(commands[:compile])
+      {state: :ok, target: target, working_directory: working_directory}
+    end
+
+    def fit
+      raise NoDataGivenError.new("Please specify your model's data before running simulations!") if data.nil?
+      `chmod +x #{CmdStanRb.configuration.model_dir}/#{name}/#{name}`
+      `#{commands[:fit]}`
+      {state: :ok, data: data}
+    end
+
+    def show
+      `#{CmdStanRb.configuration.cmdstan_dir}/bin/stansummary output.csv`
+    end
+
+    def destroy
+      path = "#{CmdStanRb.configuration.model_dir}/#{name}"
+      `rm -rvf #{path}`
+      {state: :ok, destroyed_path: path}
+    end
+
+    def commands
+      {
+        compile: "make -C #{CmdStanRb.configuration.cmdstan_dir} #{target}",
+        fit: "#{CmdStanRb.configuration.model_dir}/#{name}/#{name} sample data file=#{data_file.path}"
+      }
+    end
+
+    private
+
+    def load_model_file
+      @model_file = File.open(filename, "r")
+      @model_string = @model_file.read
+      @model_file.rewind
+    end
+
+    def create_model_file!
+      @model_file = File.open(filename, "w")
+      @model_file.write(@model_string)
+      @model_file.rewind
+    end
+
+    def data_file
+      file = File.open("#{CmdStanRb.configuration.model_dir}/#{name}/#{name}.json", "w")
+      file.write(data.to_json)
+      file.rewind
+      file
+    end
+
+    def target
+      "#{CmdStanRb.configuration.model_dir}/#{name}/#{name}"
+    end
+
+    def working_directory
+      @wd ||= `pwd`.gsub("\n", "")
+    end
+
+    def model_directory
+      "#{CmdStanRb.configuration.model_dir}/#{name}"
+    end
+
+    def filename
+      "#{CmdStanRb.configuration.model_dir}/#{name}/#{name}.stan"
+    end
+
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: cmd_stan_rb
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- 'Robin Neumann
+
+  '
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-10 00:00:00.000000000 Z
+dependencies: []
+description: Stan is a state-of-the-art platform for statistical modeling and high-performance
+  statistical computation. Thousands of users rely on Stan for statistical modeling,
+  data analysis, and prediction in the social, biological, and physical sciences,
+  engineering, and business. CmdStanRb offers bindings in Ruby to employ Stan, targeting
+  easing up the integration of Stan and Bayesian Inference into Ruby-powered environments.
+email:
+- robin.neumann@posteo.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cmd_stan_rb.gemspec
+- demo.ipynb
+- lib/cmd_stan_rb.rb
+- lib/cmd_stan_rb/configuration.rb
+- lib/cmd_stan_rb/version.rb
+- lib/stan.rb
+- lib/stan/examples.rb
+- lib/stan/model.rb
+homepage: https://github.com/neumanrq/cmd_stan_rb
+licenses: []
+metadata:
+  homepage_uri: https://github.com/neumanrq/cmd_stan_rb
+  source_code_uri: https://github.com/neumanrq/cmd_stan_rb
+  changelog_uri: https://github.com/neumanrq/cmd_stan_rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby interface to CmdStan, the command line interface to Stan, a high performance
+  statistical computing platform
+test_files: []